543 lines
18 KiB
C
Executable File
543 lines
18 KiB
C
Executable File
// meter_dts024m.c — Driver Modbus RTU para DTS024M (ESP-IDF / esp-modbus)
|
||
// Versão PRODUÇÃO (SEM AUTO-PROBE): parâmetros fixos (baud/parity/id/FC/base).
|
||
// Ajusta os #defines DTS024M_PROD_* conforme o teu medidor.
|
||
|
||
#include "meter_events.h"
|
||
#include "modbus_params.h"
|
||
#include "mbcontroller.h"
|
||
#include "esp_log.h"
|
||
#include "esp_err.h"
|
||
#include "driver/uart.h"
|
||
#include "freertos/FreeRTOS.h"
|
||
#include "freertos/task.h"
|
||
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
|
||
#include "meter_dts024m.h"
|
||
|
||
#define TAG "serial_mdb_dts024m"
|
||
|
||
// ===== UART / RS-485 =====
|
||
#define MB_PORT_NUM 2
|
||
|
||
// 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)}
|
||
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
|
||
|
||
// ===== Config PRODUÇÃO (sem AUTO-PROBE) =====
|
||
// Ajusta estes valores:
|
||
#define DTS024M_PROD_BAUD 2400
|
||
#define DTS024M_PROD_PARITY UART_PARITY_DISABLE // 0 = none; UART_PARITY_EVEN se 8E1
|
||
#define DTS024M_PROD_SLAVE_ID 1 // endereço Modbus (1..247)
|
||
#define DTS024M_PROD_AREA MB_PARAM_INPUT // MB_PARAM_INPUT (FC04) ou MB_PARAM_HOLDING (FC03)
|
||
#define DTS024M_PROD_BASE_OFFSET 0 // 0 ou 1 (depende se o mapa é 0-based ou 1-based)
|
||
|
||
// ===== Estado =====
|
||
static bool is_initialized = false;
|
||
static bool mb_started = false;
|
||
static TaskHandle_t meter_task = NULL;
|
||
|
||
// ============================================================================
|
||
// MAPA DE REGISTROS (template) — pode variar conforme firmware.
|
||
// Estes endereços são um “perfil” comum.
|
||
// ============================================================================
|
||
#define DTS024M_L1_VOLTAGE 0x0000 // U32, 0.01 V (2 regs)
|
||
#define DTS024M_L2_VOLTAGE 0x0002
|
||
#define DTS024M_L3_VOLTAGE 0x0004
|
||
|
||
#define DTS024M_L1_CURRENT 0x0006 // U32, 0.001 A (2 regs)
|
||
#define DTS024M_L2_CURRENT 0x0008
|
||
#define DTS024M_L3_CURRENT 0x000A
|
||
|
||
#define DTS024M_L1_ACTIVE_P 0x000C // I32 (two’s complement), (depende do modelo/escala)
|
||
#define DTS024M_L2_ACTIVE_P 0x000E
|
||
#define DTS024M_L3_ACTIVE_P 0x0010
|
||
|
||
#define DTS024M_PF_L1 0x001E // I16 (two’s complement), 0.001
|
||
#define DTS024M_PF_L2 0x001F
|
||
#define DTS024M_PF_L3 0x0020
|
||
|
||
#define DTS024M_FREQUENCY 0x002A // U16, 0.01 Hz
|
||
|
||
#define DTS024M_TOTAL_ACTIVE_E 0x0404 // U32, 0.01 kWh (2 regs)
|
||
|
||
// ============================================================================
|
||
// Conversões signed (two’s complement) — porque o projeto não tem PARAM_TYPE_I*
|
||
// ============================================================================
|
||
static inline int32_t s32_from_u32(uint32_t x)
|
||
{
|
||
return (x & 0x80000000u) ? (int32_t)(x - 0x100000000ULL) : (int32_t)x;
|
||
}
|
||
|
||
static inline int16_t s16_from_u16(uint16_t x)
|
||
{
|
||
return (x & 0x8000u) ? (int16_t)(x - 0x10000u) : (int16_t)x;
|
||
}
|
||
|
||
// ============================================================================
|
||
// CIDs
|
||
// ============================================================================
|
||
enum
|
||
{
|
||
CID_DTS024M_L1_VOLTAGE = 0,
|
||
CID_DTS024M_L2_VOLTAGE,
|
||
CID_DTS024M_L3_VOLTAGE,
|
||
|
||
CID_DTS024M_L1_CURRENT,
|
||
CID_DTS024M_L2_CURRENT,
|
||
CID_DTS024M_L3_CURRENT,
|
||
|
||
CID_DTS024M_L1_ACTIVE_P,
|
||
CID_DTS024M_L2_ACTIVE_P,
|
||
CID_DTS024M_L3_ACTIVE_P,
|
||
|
||
CID_DTS024M_PF_L1,
|
||
CID_DTS024M_PF_L2,
|
||
CID_DTS024M_PF_L3,
|
||
|
||
CID_DTS024M_FREQUENCY,
|
||
CID_DTS024M_TOTAL_ACTIVE_E,
|
||
};
|
||
|
||
// ============================================================================
|
||
// DESCRIPTORS (TEMPLATE) — copiamos para RAM e ajustamos:
|
||
// - slave_id
|
||
// - base offset (0/1)
|
||
// - mb_param_type (HOLDING/INPUT)
|
||
// ============================================================================
|
||
static const mb_parameter_descriptor_t device_parameters_dts024m_tmpl[] = {
|
||
|
||
// Tensões (U32 / 2 regs) — 0.01 V
|
||
{CID_DTS024M_L1_VOLTAGE, STR("L1 Voltage"), STR("V"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L1_VOLTAGE, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_L2_VOLTAGE, STR("L2 Voltage"), STR("V"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L2_VOLTAGE, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L3_VOLTAGE, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
// Correntes (U32 / 2 regs) — 0.001 A
|
||
{CID_DTS024M_L1_CURRENT, STR("L1 Current"), STR("A"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L1_CURRENT, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_L2_CURRENT, STR("L2 Current"), STR("A"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L2_CURRENT, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_L3_CURRENT, STR("L3 Current"), STR("A"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L3_CURRENT, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
// Potência ativa por fase (U32 / 2 regs no descriptor; interpretamos como signed I32)
|
||
{CID_DTS024M_L1_ACTIVE_P, STR("L1 Active Power"), STR("W"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L1_ACTIVE_P, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_L2_ACTIVE_P, STR("L2 Active Power"), STR("W"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L2_ACTIVE_P, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_L3_ACTIVE_P, STR("L3 Active Power"), STR("W"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_L3_ACTIVE_P, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
|
||
// PF (U16 / 1 reg; interpretamos como signed I16) — 0.001
|
||
{CID_DTS024M_PF_L1, STR("L1 PF"), STR(""), 1,
|
||
MB_PARAM_HOLDING, DTS024M_PF_L1, 1,
|
||
0, PARAM_TYPE_U16, 2, OPTS(0, 65535, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_PF_L2, STR("L2 PF"), STR(""), 1,
|
||
MB_PARAM_HOLDING, DTS024M_PF_L2, 1,
|
||
0, PARAM_TYPE_U16, 2, OPTS(0, 65535, 1), PAR_PERMS_READ},
|
||
|
||
{CID_DTS024M_PF_L3, STR("L3 PF"), STR(""), 1,
|
||
MB_PARAM_HOLDING, DTS024M_PF_L3, 1,
|
||
0, PARAM_TYPE_U16, 2, OPTS(0, 65535, 1), PAR_PERMS_READ},
|
||
|
||
// Frequência (U16 / 1 reg) — 0.01 Hz
|
||
{CID_DTS024M_FREQUENCY, STR("Frequency"), STR("Hz"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_FREQUENCY, 1,
|
||
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
|
||
|
||
// Energia ativa total (U32 / 2 regs) — 0.01 kWh
|
||
{CID_DTS024M_TOTAL_ACTIVE_E, STR("Total Active Energy"), STR("kWh"), 1,
|
||
MB_PARAM_HOLDING, DTS024M_TOTAL_ACTIVE_E, 2,
|
||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||
};
|
||
|
||
static mb_parameter_descriptor_t device_parameters_dts024m[ARRAY_SIZE(device_parameters_dts024m_tmpl)];
|
||
static const uint16_t num_device_parameters_dts024m = ARRAY_SIZE(device_parameters_dts024m);
|
||
|
||
static void dts024m_build_descriptors(uint8_t slave_id, uint16_t base_offset, mb_param_type_t area)
|
||
{
|
||
memcpy(device_parameters_dts024m,
|
||
device_parameters_dts024m_tmpl,
|
||
sizeof(device_parameters_dts024m));
|
||
|
||
for (uint16_t i = 0; i < num_device_parameters_dts024m; ++i)
|
||
{
|
||
device_parameters_dts024m[i].mb_slave_addr = slave_id;
|
||
device_parameters_dts024m[i].mb_reg_start =
|
||
(uint16_t)(device_parameters_dts024m[i].mb_reg_start + base_offset);
|
||
device_parameters_dts024m[i].mb_param_type = area; // HOLDING (FC03) ou INPUT (FC04)
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// Modbus master init (fixo) — garante ordem correta (start -> uart_set_mode)
|
||
// ============================================================================
|
||
static esp_err_t dts024m_master_reinit(uint32_t baud, uart_parity_t parity)
|
||
{
|
||
if (mb_started)
|
||
{
|
||
(void)mbc_master_destroy();
|
||
mb_started = false;
|
||
}
|
||
|
||
if (uart_is_driver_installed(MB_PORT_NUM))
|
||
{
|
||
uart_driver_delete(MB_PORT_NUM);
|
||
}
|
||
|
||
mb_communication_info_t comm = {
|
||
.port = MB_PORT_NUM,
|
||
.mode = MB_MODE_RTU,
|
||
.baudrate = baud,
|
||
.parity = parity};
|
||
|
||
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;
|
||
}
|
||
|
||
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 de uart_set_mode (driver UART costuma ser instalado no start)
|
||
err = mbc_master_start();
|
||
if (err != ESP_OK)
|
||
{
|
||
(void)mbc_master_destroy();
|
||
return err;
|
||
}
|
||
|
||
mb_started = true;
|
||
|
||
err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX);
|
||
if (err != ESP_OK)
|
||
{
|
||
(void)mbc_master_destroy();
|
||
mb_started = false;
|
||
return err;
|
||
}
|
||
|
||
vTaskDelay(pdMS_TO_TICKS(40));
|
||
return ESP_OK;
|
||
}
|
||
|
||
// ============================================================================
|
||
// Post do evento de medição
|
||
// ============================================================================
|
||
static void meter_dts024m_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), portMAX_DELAY);
|
||
if (err != ESP_OK)
|
||
{
|
||
ESP_LOGW(TAG, "Falha ao emitir evento: %s", esp_err_to_name(err));
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// Task de polling
|
||
// ============================================================================
|
||
static void serial_mdb_dts024m_task(void *param)
|
||
{
|
||
(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;
|
||
|
||
int p_w[3] = {0};
|
||
|
||
vTaskDelay(pdMS_TO_TICKS(200)); // settle
|
||
|
||
while (1)
|
||
{
|
||
for (uint16_t cid = 0; cid < num_device_parameters_dts024m; cid++)
|
||
{
|
||
err = mbc_master_get_cid_info(cid, &desc);
|
||
if (err != ESP_OK || !desc)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
uint8_t type = 0;
|
||
uint16_t raw_u16 = 0;
|
||
uint32_t raw_u32 = 0;
|
||
|
||
void *value_ptr = &raw_u16;
|
||
|
||
// U32
|
||
switch (cid)
|
||
{
|
||
case CID_DTS024M_L1_VOLTAGE:
|
||
case CID_DTS024M_L2_VOLTAGE:
|
||
case CID_DTS024M_L3_VOLTAGE:
|
||
case CID_DTS024M_L1_CURRENT:
|
||
case CID_DTS024M_L2_CURRENT:
|
||
case CID_DTS024M_L3_CURRENT:
|
||
case CID_DTS024M_L1_ACTIVE_P:
|
||
case CID_DTS024M_L2_ACTIVE_P:
|
||
case CID_DTS024M_L3_ACTIVE_P:
|
||
case CID_DTS024M_TOTAL_ACTIVE_E:
|
||
value_ptr = &raw_u32;
|
||
break;
|
||
default:
|
||
value_ptr = &raw_u16;
|
||
break;
|
||
}
|
||
|
||
// 1 retry simples em caso de timeout (podes remover se quiseres menos carga)
|
||
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)
|
||
{
|
||
// V (0.01V)
|
||
case CID_DTS024M_L1_VOLTAGE:
|
||
v[0] = ((float)raw_u32) * 0.01f;
|
||
break;
|
||
case CID_DTS024M_L2_VOLTAGE:
|
||
v[1] = ((float)raw_u32) * 0.01f;
|
||
break;
|
||
case CID_DTS024M_L3_VOLTAGE:
|
||
v[2] = ((float)raw_u32) * 0.01f;
|
||
break;
|
||
|
||
// I (0.001A)
|
||
case CID_DTS024M_L1_CURRENT:
|
||
i[0] = ((float)raw_u32) * 0.001f;
|
||
break;
|
||
case CID_DTS024M_L2_CURRENT:
|
||
i[1] = ((float)raw_u32) * 0.001f;
|
||
break;
|
||
case CID_DTS024M_L3_CURRENT:
|
||
i[2] = ((float)raw_u32) * 0.001f;
|
||
break;
|
||
|
||
// P ativa (two’s complement I32) — atenção: escala depende do modelo
|
||
case CID_DTS024M_L1_ACTIVE_P:
|
||
p_w[0] = (int)s32_from_u32(raw_u32);
|
||
break;
|
||
case CID_DTS024M_L2_ACTIVE_P:
|
||
p_w[1] = (int)s32_from_u32(raw_u32);
|
||
break;
|
||
case CID_DTS024M_L3_ACTIVE_P:
|
||
p_w[2] = (int)s32_from_u32(raw_u32);
|
||
break;
|
||
|
||
// PF (two’s complement I16; 0.001)
|
||
case CID_DTS024M_PF_L1:
|
||
pf[0] = ((float)s16_from_u16(raw_u16)) * 0.001f;
|
||
break;
|
||
case CID_DTS024M_PF_L2:
|
||
pf[1] = ((float)s16_from_u16(raw_u16)) * 0.001f;
|
||
break;
|
||
case CID_DTS024M_PF_L3:
|
||
pf[2] = ((float)s16_from_u16(raw_u16)) * 0.001f;
|
||
break;
|
||
|
||
// Freq (0.01Hz)
|
||
case CID_DTS024M_FREQUENCY:
|
||
freq = ((float)raw_u16) * 0.01f;
|
||
break;
|
||
|
||
// Energia (0.01kWh)
|
||
case CID_DTS024M_TOTAL_ACTIVE_E:
|
||
total_kwh = ((float)raw_u32) * 0.01f;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
ESP_LOGD(TAG, "%s (cid=%u) ok (u16=%u u32=%u)",
|
||
desc->param_key, cid, (unsigned)raw_u16, (unsigned)raw_u32);
|
||
}
|
||
else
|
||
{
|
||
ESP_LOGE(TAG, "CID %u (%s) read failed: %s",
|
||
cid, desc->param_key, esp_err_to_name(err));
|
||
}
|
||
|
||
vTaskDelay(POLL_INTERVAL);
|
||
}
|
||
|
||
// 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_dts024m_post_event(v, i, p_w, freq, pf_avg, total_kwh);
|
||
vTaskDelay(UPDATE_INTERVAL);
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// Init / Start / Stop
|
||
// ============================================================================
|
||
esp_err_t meter_dts024m_init(void)
|
||
{
|
||
if (is_initialized)
|
||
{
|
||
ESP_LOGW(TAG, "Already initialized");
|
||
return ESP_ERR_INVALID_STATE;
|
||
}
|
||
|
||
// init fixo (produção)
|
||
esp_err_t err = dts024m_master_reinit(DTS024M_PROD_BAUD, DTS024M_PROD_PARITY);
|
||
if (err != ESP_OK)
|
||
{
|
||
ESP_LOGE(TAG, "master_reinit failed: %s", esp_err_to_name(err));
|
||
return err;
|
||
}
|
||
|
||
// monta descriptors reais com ID/offset/area fixos
|
||
dts024m_build_descriptors(DTS024M_PROD_SLAVE_ID, DTS024M_PROD_BASE_OFFSET, DTS024M_PROD_AREA);
|
||
|
||
// aplica descriptors reais
|
||
esp_err_t derr = mbc_master_set_descriptor(device_parameters_dts024m,
|
||
num_device_parameters_dts024m);
|
||
if (derr != ESP_OK)
|
||
{
|
||
ESP_LOGE(TAG, "set_descriptor failed: %s", esp_err_to_name(derr));
|
||
return derr;
|
||
}
|
||
|
||
is_initialized = true;
|
||
ESP_LOGI(TAG, "DTS024M initialized (PROD) baud=%d parity=%d id=%d area=%s base=%d",
|
||
DTS024M_PROD_BAUD,
|
||
(int)DTS024M_PROD_PARITY,
|
||
DTS024M_PROD_SLAVE_ID,
|
||
(DTS024M_PROD_AREA == MB_PARAM_HOLDING ? "FC03" : "FC04"),
|
||
DTS024M_PROD_BASE_OFFSET);
|
||
|
||
return ESP_OK;
|
||
}
|
||
|
||
esp_err_t meter_dts024m_start(void)
|
||
{
|
||
if (!is_initialized)
|
||
{
|
||
ESP_LOGE(TAG, "Not initialized");
|
||
return ESP_ERR_INVALID_STATE;
|
||
}
|
||
|
||
if (meter_task == NULL)
|
||
{
|
||
xTaskCreate(serial_mdb_dts024m_task,
|
||
"meter_dts024m_task",
|
||
4096, NULL, 3, &meter_task);
|
||
ESP_LOGI(TAG, "DTS024M task started");
|
||
}
|
||
|
||
return ESP_OK;
|
||
}
|
||
|
||
void meter_dts024m_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, "DTS024M task stopped");
|
||
}
|
||
|
||
if (mb_started)
|
||
{
|
||
(void)mbc_master_destroy();
|
||
mb_started = false;
|
||
}
|
||
|
||
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 DTS024M cleaned up");
|
||
}
|