// 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 #include #include #include #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(); }