admin/chargeflow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2a803fcef16d76dedd639fb68cb097b574501f5a
chargeflow/components/meter_manager/driver/meter_modbus/meter_orno526.c

613 lines
17 KiB
C
Raw Blame History

// components/meter_manager/driver/meter_modbus/meter_orno526.c
// Driver Modbus RTU/RS485 para ORNO OR-WE-526.
//
// Configuração validada em hardware por USB-RS485:
// - Slave ID 1
// - 9600 baud, 8N1
// - FC04 (Input Registers)
// - INT32 transmitido no fio como ABCD; nesta versão do esp-modbus,
// PARAM_TYPE_I32_CDAB produz o inteiro nativo correto no ESP32.
//
// Mapa usado:
// 0x0100 tensão INT32 / 1000 V
// 0x0102 corrente INT32 / 1000 A
// 0x0104 potência ativa INT32 W
// 0x0106 potência aparente INT32 VA
// 0x0108 potência reativa INT32 var
// 0x010A frequência UINT16 / 10 Hz
// 0x010B fator de potência UINT16 / 1000
// 0x010E energia ativa direta INT32 / 100 kWh
// 0x0140 energia reativa total INT32 / 100 kvarh
//
// O OR-WE-526 é monofásico: apenas o índice de fase 0 é preenchido.
#include "meter_orno526.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 <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#define TAG "serial_mdb_orno526"
// ===== UART / Modbus =====
#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 ORNO526_SLAVE_ID 1
// ===== Temporizações =====
#define UPDATE_INTERVAL pdMS_TO_TICKS(3000)
#define POLL_INTERVAL pdMS_TO_TICKS(100)
#define STOP_WAIT_STEP pdMS_TO_TICKS(10)
#define STOP_WAIT_ITERATIONS 200
#define OPTS(minimum, maximum, step_value) \
{.opt1 = (minimum), .opt2 = (maximum), .opt3 = (step_value)}
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
// ===== Estado =====
static bool is_initialized = false;
static volatile bool task_should_run = false;
static TaskHandle_t meter_task = NULL;
static const char *meter_source = "GRID";
// ===== CIDs =====
typedef 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,
CID_POWER_FACTOR,
CID_COUNT
} orno526_cid_t;
#define ORNO526_REQUIRED_MASK \
((1UL << CID_L1_VOLTAGE) | \
(1UL << CID_L1_CURRENT) | \
(1UL << CID_ACTIVE_POWER))
// ===== Endereços Modbus =====
#define REG_L1_VOLTAGE 0x0100U
#define REG_L1_CURRENT 0x0102U
#define REG_ACTIVE_POWER 0x0104U
#define REG_APPARENT_POWER 0x0106U
#define REG_REACTIVE_POWER 0x0108U
#define REG_FREQUENCY 0x010AU
#define REG_POWER_FACTOR 0x010BU
#define REG_FORWARD_ACTIVE_ENERGY 0x010EU
#define REG_TOTAL_REACTIVE_ENERGY 0x0140U
// A documentação mostra ABCD no fio. Tal como validado noutros drivers deste
// projeto, o tipo CDAB do esp-modbus faz a conversão correta para o host ESP32.
#ifndef ORNO526_I32_PARAM_TYPE
#define ORNO526_I32_PARAM_TYPE PARAM_TYPE_I32_CDAB
#endif
// param_offset fica a zero porque cada leitura usa um buffer local alinhado.
static const mb_parameter_descriptor_t device_parameters_orno526[CID_COUNT] = {
{CID_ACTIVE_ENERGY, "Forward Active Energy", "kWh", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_FORWARD_ACTIVE_ENERGY, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(0, 2147483647, 1), PAR_PERMS_READ},
{CID_REACTIVE_ENERGY, "Total Reactive Energy", "kvarh", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_TOTAL_REACTIVE_ENERGY, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(0, 2147483647, 1), PAR_PERMS_READ},
{CID_ACTIVE_POWER, "Active Power", "W", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_ACTIVE_POWER, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
{CID_APPARENT_POWER, "Apparent Power", "VA", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_APPARENT_POWER, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
{CID_REACTIVE_POWER, "Reactive Power", "var", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_REACTIVE_POWER, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
{CID_L1_CURRENT, "L1 Current", "A", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_L1_CURRENT, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
{CID_L1_VOLTAGE, "L1 Voltage", "V", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_L1_VOLTAGE, 2, 0,
ORNO526_I32_PARAM_TYPE, 4, OPTS(0, 300000, 1), PAR_PERMS_READ},
{CID_FREQUENCY, "Frequency", "Hz", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_FREQUENCY, 1, 0,
PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
{CID_POWER_FACTOR, "Power Factor", "", ORNO526_SLAVE_ID,
MB_PARAM_INPUT, REG_POWER_FACTOR, 1, 0,
PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
};
static bool orno526_is_16bit_cid(uint16_t cid)
{
return cid == CID_FREQUENCY || cid == CID_POWER_FACTOR;
}
static bool orno526_value_is_valid(uint16_t cid, float value)
{
if (!isfinite(value))
return false;
switch (cid)
{
case CID_ACTIVE_ENERGY:
case CID_REACTIVE_ENERGY:
return value >= 0.0f && value <= 10000000.0f;
case CID_ACTIVE_POWER:
case CID_REACTIVE_POWER:
return value >= -100000.0f && value <= 100000.0f;
case CID_APPARENT_POWER:
return value >= 0.0f && value <= 100000.0f;
case CID_L1_CURRENT:
return value >= -100.0f && value <= 100.0f;
case CID_L1_VOLTAGE:
return value >= 0.0f && value <= 300.0f;
case CID_FREQUENCY:
return value >= 0.0f && value <= 100.0f;
case CID_POWER_FACTOR:
return value >= 0.0f && value <= 1.1f;
default:
return false;
}
}
static float orno526_scale_i32(uint16_t cid, int32_t raw)
{
switch (cid)
{
case CID_L1_VOLTAGE:
case CID_L1_CURRENT:
return (float)raw / 1000.0f;
case CID_ACTIVE_ENERGY:
case CID_REACTIVE_ENERGY:
return (float)raw / 100.0f;
case CID_ACTIVE_POWER:
case CID_APPARENT_POWER:
case CID_REACTIVE_POWER:
default:
return (float)raw;
}
}
static float orno526_scale_u16(uint16_t cid, uint16_t raw)
{
switch (cid)
{
case CID_FREQUENCY:
return (float)raw / 10.0f;
case CID_POWER_FACTOR:
return (float)raw / 1000.0f;
default:
return (float)raw;
}
}
static void serial_mdb_task(void *param)
{
(void)param;
while (task_should_run)
{
float voltage[3] = {0.0f, 0.0f, 0.0f};
float current[3] = {0.0f, 0.0f, 0.0f};
int32_t watt[3] = {0, 0, 0};
float frequency_hz = 0.0f;
float power_factor = 0.0f;
float active_energy_kwh = 0.0f;
float reactive_energy_kvarh = 0.0f;
float apparent_power_va = 0.0f;
float reactive_power_var = 0.0f;
uint32_t valid_mask = 0U;
for (uint16_t cid = 0; cid < CID_COUNT && task_should_run; ++cid)
{
const mb_parameter_descriptor_t *desc = NULL;
esp_err_t err = mbc_master_get_cid_info(cid, &desc);
if (err != ESP_OK || !desc)
{
ESP_LOGE(TAG, "%s get_cid_info(%u) failed: %s",
meter_source, (unsigned)cid, esp_err_to_name(err));
continue;
}
int32_t raw_i32 = 0;
uint16_t raw_u16 = 0;
void *data_ptr = orno526_is_16bit_cid(cid)
? (void *)&raw_u16
: (void *)&raw_i32;
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",
meter_source,
(unsigned)cid,
desc->param_key,
esp_err_to_name(err));
vTaskDelay(POLL_INTERVAL);
continue;
}
const float value = orno526_is_16bit_cid(cid)
? orno526_scale_u16(cid, raw_u16)
: orno526_scale_i32(cid, raw_i32);
if (!orno526_value_is_valid(cid, value))
{
if (orno526_is_16bit_cid(cid))
{
ESP_LOGW(TAG,
"%s %s invalid: raw=0x%04X value=%.6f",
meter_source,
desc->param_key,
(unsigned)raw_u16,
(double)value);
}
else
{
ESP_LOGW(TAG,
"%s %s invalid: raw=%ld (0x%08lX) value=%.6f",
meter_source,
desc->param_key,
(long)raw_i32,
(unsigned long)(uint32_t)raw_i32,
(double)value);
}
vTaskDelay(POLL_INTERVAL);
continue;
}
valid_mask |= (1UL << cid);
ESP_LOGD(TAG, "%s %s: %.3f %s",
meter_source,
desc->param_key,
(double)value,
desc->param_units);
switch (cid)
{
case CID_ACTIVE_ENERGY:
active_energy_kwh = value;
break;
case CID_REACTIVE_ENERGY:
reactive_energy_kvarh = value;
break;
case CID_ACTIVE_POWER:
watt[0] = (int32_t)lrintf(value);
break;
case CID_APPARENT_POWER:
apparent_power_va = value;
break;
case CID_REACTIVE_POWER:
reactive_power_var = value;
break;
case CID_L1_CURRENT:
// irms deve ser não negativo; o sentido é representado pela potência.
current[0] = fabsf(value);
break;
case CID_L1_VOLTAGE:
voltage[0] = value;
break;
case CID_FREQUENCY:
frequency_hz = value;
break;
case CID_POWER_FACTOR:
power_factor = value;
break;
default:
break;
}
vTaskDelay(POLL_INTERVAL);
}
if (!task_should_run)
break;
if ((valid_mask & ORNO526_REQUIRED_MASK) != ORNO526_REQUIRED_MASK)
{
ESP_LOGW(TAG,
"%s incomplete OR-WE-526 sample, mask=0x%03lX",
meter_source,
(unsigned long)valid_mask);
vTaskDelay(UPDATE_INTERVAL);
continue;
}
meter_event_data_t evt = {
.source = meter_source,
.watt_total = watt[0],
.frequency = frequency_hz,
.power_factor = power_factor,
.total_energy = active_energy_kwh,
.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));
ESP_LOGI(TAG,
"%s OR-WE-526 event: V=%.3fV I=%.3fA P=%ldW "
"S=%.0fVA Q=%.0fvar E=%.2fkWh Er=%.2fkvarh "
"Hz=%.2f PF=%.3f mask=0x%03lX",
meter_source,
(double)voltage[0],
(double)current[0],
(long)evt.watt_total,
(double)apparent_power_va,
(double)reactive_power_var,
(double)active_energy_kwh,
(double)reactive_energy_kvarh,
(double)frequency_hz,
(double)power_factor,
(unsigned long)valid_mask);
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",
meter_source, esp_err_to_name(post_err));
}
vTaskDelay(UPDATE_INTERVAL);
}
ESP_LOGI(TAG, "OR-WE-526 task stopped");
meter_task = NULL;
vTaskDelete(NULL);
}
static esp_err_t meter_orno526_init_common(const char *source)
{
if (!source)
return ESP_ERR_INVALID_ARG;
if (is_initialized)
{
if (strcmp(meter_source, source) == 0)
return ESP_OK;
ESP_LOGE(TAG,
"OR-WE-526 already initialized as %s; cannot reinitialize as %s",
meter_source,
source);
return ESP_ERR_INVALID_STATE;
}
meter_source = source;
ESP_LOGI(TAG, "meter_orno526 init as %s", meter_source);
mb_communication_info_t comm = {
.port = MB_PORT_NUM,
.mode = MB_MODE_RTU,
.baudrate = MB_DEV_SPEED,
.parity = UART_PARITY_DISABLE, // Validado: 9600 8N1
};
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: %s", esp_err_to_name(err));
return err;
}
err = mbc_master_setup(&comm);
if (err != ESP_OK)
goto fail_destroy_master;
err = uart_set_pin(MB_PORT_NUM,
MB_UART_TXD,
MB_UART_RXD,
MB_UART_RTS,
UART_PIN_NO_CHANGE);
if (err != ESP_OK)
goto fail_destroy_master;
err = uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS);
if (err != ESP_OK)
goto fail_destroy_master;
err = uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0);
if (err != ESP_OK)
goto fail_destroy_master;
err = uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1);
if (err != ESP_OK)
goto fail_destroy_master;
err = mbc_master_start();
if (err != ESP_OK)
goto fail_destroy_master;
// O driver UART é instalado por mbc_master_start(); só depois ativamos RS485.
err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX);
if (err != ESP_OK)
goto fail_destroy_master;
vTaskDelay(pdMS_TO_TICKS(20));
err = mbc_master_set_descriptor(device_parameters_orno526,
ARRAY_SIZE(device_parameters_orno526));
if (err != ESP_OK)
{
ESP_LOGE(TAG, "mbc_master_set_descriptor failed: %s",
esp_err_to_name(err));
goto fail_destroy_master;
}
// Reduz para INFO/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);
is_initialized = true;
return ESP_OK;
fail_destroy_master:
ESP_LOGE(TAG, "OR-WE-526 initialization failed: %s", esp_err_to_name(err));
(void)mbc_master_destroy();
if (uart_is_driver_installed(MB_PORT_NUM))
(void)uart_driver_delete(MB_PORT_NUM);
return err;
}
esp_err_t meter_orno526_init(void)
{
return meter_orno526_grid_init();
}
esp_err_t meter_orno526_grid_init(void)
{
return meter_orno526_init_common("GRID");
}
esp_err_t meter_orno526_evse_init(void)
{
return meter_orno526_init_common("EVSE");
}
esp_err_t meter_orno526_start(void)
{
if (!is_initialized)
{
ESP_LOGE(TAG, "meter_orno526 not initialized");
return ESP_ERR_INVALID_STATE;
}
if (meter_task != NULL)
return ESP_OK;
task_should_run = true;
BaseType_t ok = xTaskCreate(serial_mdb_task,
"meter_orno526_task",
4096,
NULL,
3,
&meter_task);
if (ok != pdPASS)
{
task_should_run = false;
meter_task = NULL;
ESP_LOGE(TAG, "Failed to create OR-WE-526 task");
return ESP_ERR_NO_MEM;
}
ESP_LOGI(TAG, "OR-WE-526 %s task started", meter_source);
return ESP_OK;
}
esp_err_t meter_orno526_grid_start(void)
{
return meter_orno526_start();
}
esp_err_t meter_orno526_evse_start(void)
{
return meter_orno526_start();
}
void meter_orno526_stop(void)
{
if (!is_initialized)
return;
ESP_LOGI(TAG, "Stopping OR-WE-526 %s", meter_source);
task_should_run = false;
for (int i = 0; i < STOP_WAIT_ITERATIONS && meter_task != NULL; ++i)
vTaskDelay(STOP_WAIT_STEP);
if (meter_task != NULL)
{
ESP_LOGW(TAG, "OR-WE-526 task did not stop 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))
{
err = uart_driver_delete(MB_PORT_NUM);
if (err != ESP_OK)
{
ESP_LOGW(TAG, "uart_driver_delete returned %s",
esp_err_to_name(err));
}
}
is_initialized = false;
meter_source = "GRID";
}
void meter_orno526_grid_stop(void)
{
meter_orno526_stop();
}
void meter_orno526_evse_stop(void)
{
meter_orno526_stop();
}
Reference in New Issue View Git Blame Copy Permalink