refact 3

components/meter_ade7758/src/energy_meter.c

@@ -0,0 +1,237 @@
+#include <memory.h>
+#include <math.h>
+#include <stdbool.h>  // <- Necessário para bool
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include "esp_log.h"
+#include "esp_timer.h"
+#include "nvs.h"
+
+#include "meter.h"
+#include "orno_modbus.h"
+
+#define NVS_NAMESPACE "evse_emeter"
+#define NVS_MODEL "model"
+#define NVS_STATE "state"
+
+static const char *TAG = "energy_meter";
+
+static nvs_handle nvs;
+
+static bool state = false;
+static meter_model_t model = ENERGY_METER_NONE;
+
+static uint16_t power = 0;
+static bool has_session = false;
+static int64_t start_time = 0;
+static uint32_t charging_time = 0;  // ms
+static uint32_t consumption = 0;    // Ws
+static float cur[3] = {0, 0, 0};
+static float vlt[3] = {0, 0, 0};
+static int64_t prev_time = 0;
+
+static void set_calc_power(float p, uint32_t delta_ms)
+{
+    consumption += roundf((p * delta_ms) / 1000.0f);
+    power = roundf(p);
+}
+
+void energy_meter_init(void)
+{
+    ESP_LOGI(TAG, "energy_meter_init");
+    ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
+
+    uint8_t u8 = ENERGY_METER_NONE;
+    nvs_get_u8(nvs, NVS_MODEL, &u8);
+    model = u8;
+}
+
+bool meter_get_state(void)
+{
+    return orno_modbus_get_meter_state();
+}
+
+esp_err_t meter_set_state(bool _state)
+{
+    state = _state;
+    nvs_set_u8(nvs, NVS_STATE, state);
+    nvs_commit(nvs);
+    return ESP_OK;
+}
+
+meter_model_t meter_get_model(void)
+{
+    return model;
+}
+
+esp_err_t meter_set_model(meter_model_t _model)
+{
+    ESP_LOGI(TAG, "meter_set_model");
+
+    if (_model < 0 || _model > ENERGY_METER_ORNO_517) {
+        ESP_LOGE(TAG, "Model out of range");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    model = _model;
+    nvs_set_u8(nvs, NVS_MODEL, model);
+    nvs_commit(nvs);
+    orno_modbus_set_model(model != ENERGY_METER_NONE);
+    return ESP_OK;
+}
+
+void energy_meter_start_session(void)
+{
+    if (!has_session) {
+        ESP_LOGI(TAG, "Start session");
+        start_time = esp_timer_get_time();
+        has_session = true;
+        //meter_start();
+    }
+}
+
+void energy_meter_stop_session(void)
+{
+    if (has_session) {
+        ESP_LOGI(TAG, "Stop session");
+        start_time = 0;
+        consumption = 0;
+        charging_time = 0;
+        has_session = false;
+        //meter_stop();
+    }
+}
+
+void energy_meter_process(bool charging, uint16_t charging_current)
+{
+    int64_t now = esp_timer_get_time();
+    uint32_t delta_ms = (now - prev_time) / 1000;
+
+    if (charging && meter_is_running()) {
+        MeterData data = meter_getData();
+
+        vlt[0] = data.vrmsA;
+        vlt[1] = data.vrmsB;
+        vlt[2] = data.vrmsC;
+
+        cur[0] = data.irmsA;
+        cur[1] = data.irmsB;
+        cur[2] = data.irmsC;
+
+        uint32_t total_power = data.wattA + data.wattB + data.wattC;
+
+        set_calc_power((float)total_power, delta_ms);
+        charging_time += delta_ms;
+    } else {
+        vlt[0] = vlt[1] = vlt[2] = 0;
+        cur[0] = cur[1] = cur[2] = 0;
+        power = 0;
+    }
+
+    prev_time = now;
+}
+
+uint32_t energy_meter_get_power(void)
+{
+    return power;
+}
+
+uint32_t energy_meter_get_session_time(void)
+{
+    return has_session ? (esp_timer_get_time() - start_time) / 1000000 : 0;
+}
+
+uint32_t energy_meter_get_charging_time(void)
+{
+    return charging_time / 1000;
+}
+
+uint32_t energy_meter_get_consumption(void)
+{
+    return consumption / 3600;
+}
+
+void energy_meter_get_voltage(float *voltage)
+{
+    memcpy(voltage, vlt, sizeof(vlt));
+}
+
+float energy_meter_get_l1_voltage(void)
+{
+    return vlt[0];
+}
+
+float energy_meter_get_l2_voltage(void)
+{
+    return vlt[1];
+}
+
+float energy_meter_get_l3_voltage(void)
+{
+    return vlt[2];
+}
+
+void energy_meter_get_current(float *current)
+{
+    memcpy(current, cur, sizeof(cur));
+}
+
+float energy_meter_get_l1_current(void)
+{
+    return cur[0];
+}
+
+float energy_meter_get_l2_current(void)
+{
+    return cur[1];
+}
+
+float energy_meter_get_l3_current(void)
+{
+    return cur[2];
+}
+
+
+const char *meter_state_to_str(bool state)
+{
+    return state == true ? "CONNECTED" : "NOT CONNECTED";
+}
+
+const char *meter_model_to_str(meter_model_t mode)
+{
+
+    switch (mode)
+    {
+    case ENERGY_METER_NONE:
+        return "NONE";
+    case ENERGY_METER_ORNO_515:
+        return "OR-WE-515";
+    case ENERGY_METER_ORNO_517:
+        return "OR-WE-517";
+    default:
+        return "NONE";
+    }
+}
+
+meter_model_t meter_str_to_model(const char *str)
+{
+    if (!strcmp(str, "NONE"))
+    {
+        return ENERGY_METER_NONE;
+    }
+    if (!strcmp(str, "OR-WE-515"))
+    {
+        return ENERGY_METER_ORNO_515;
+    }
+    if (!strcmp(str, "OR-WE-517"))
+    {
+        return ENERGY_METER_ORNO_517;
+    }
+
+    return ENERGY_METER_NONE;
+}
+
+bool meter_str_to_state(const char *str)
+{
+    return strcmp(str, "CONNECTED") == 0;
+}

components/meter_ade7758/src/meter.c

@@ -0,0 +1,174 @@
+#include "meter.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "esp_log.h"
+#include "esp_system.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+
+#include "driver/spi_master.h"
+#include "driver/gpio.h"
+
+#include "ade7758.h"
+#include "evse_api.h"
+
+#define TAG "meter"
+
+// SPI Config
+#define PIN_NUM_CLK  15
+#define PIN_NUM_MOSI 2
+#define PIN_NUM_MISO 4
+#define PIN_NUM_CS   23
+#define EEPROM_HOST  HSPI_HOST
+
+// Calibration constants
+#define VRMS_CAL  4732.78f
+#define IRMS_CAL  53416.0f
+
+#define METER_READ_INTERVAL_MS 5000
+
+static TaskHandle_t meter_task = NULL;
+static MeterData metervalue;
+static SemaphoreHandle_t meter_mutex = NULL;
+
+static uint32_t meter_watchdog_counter = 0;
+
+void meter_initData(void) {
+    if (xSemaphoreTake(meter_mutex, pdMS_TO_TICKS(10)) == pdTRUE) {
+        memset(&metervalue, 0, sizeof(metervalue));
+        xSemaphoreGive(meter_mutex);
+    } else {
+        ESP_LOGE(TAG, "Falha ao adquirir semáforo para zerar dados.");
+    }
+}
+
+MeterData meter_getData(void) {
+    MeterData copy;
+    if (xSemaphoreTake(meter_mutex, pdMS_TO_TICKS(10)) == pdTRUE) {
+        copy = metervalue;
+        xSemaphoreGive(meter_mutex);
+    } else {
+        ESP_LOGE(TAG, "Falha ao adquirir semáforo para leitura de dados.");
+        memset(&copy, 0, sizeof(copy));
+    }
+    return copy;
+}
+
+bool meter_is_running(void) {
+    return meter_task != NULL;
+}
+
+uint32_t meter_get_watchdog_counter(void) {
+    return meter_watchdog_counter;
+}
+
+static void meter_task_func(void *param) {
+    ESP_LOGI(TAG, "Meter task started");
+
+    MeterData previousData = {0};
+    bool dataChanged = false;
+
+    while (true) {
+        if (evse_state_is_charging(evse_get_state())) {
+            MeterData local = {0};
+
+            local.vrmsA = avrms() / VRMS_CAL;
+            local.vrmsB = bvrms() / VRMS_CAL;
+            local.vrmsC = cvrms() / VRMS_CAL;
+
+            local.irmsA = airms() / IRMS_CAL;
+            local.irmsB = birms() / IRMS_CAL;
+            local.irmsC = cirms() / IRMS_CAL;
+
+            ESP_LOGD(TAG, "VRMS: A=%.2f, B=%.2f, C=%.2f", local.vrmsA, local.vrmsB, local.vrmsC);
+            ESP_LOGD(TAG, "IRMS: A=%.2f, B=%.2f, C=%.2f", local.irmsA, local.irmsB, local.irmsC);
+
+            if (setPotLine(PHASE_A, 20)) {
+                local.wattA = getWatt(PHASE_A);
+                ESP_LOGD(TAG, "Watt A: %" PRIi32, local.wattA);
+            }
+
+            if (setPotLine(PHASE_B, 20)) {
+                local.wattB = getWatt(PHASE_B);
+                ESP_LOGD(TAG, "Watt B: %" PRIi32, local.wattB);
+            }
+
+            if (setPotLine(PHASE_C, 20)) {
+                local.wattC = getWatt(PHASE_C);
+                ESP_LOGI(TAG, "Watt C: %" PRIi32, local.wattC);
+            }
+
+            // Verifique se os dados mudaram antes de atualizar
+            if (memcmp(&local, &previousData, sizeof(MeterData)) != 0) {
+                dataChanged = true;
+                previousData = local;
+            } else {
+                dataChanged = false;
+            }
+
+            if (dataChanged && xSemaphoreTake(meter_mutex, pdMS_TO_TICKS(10)) == pdTRUE) {
+                metervalue = local;
+                meter_watchdog_counter++;
+                xSemaphoreGive(meter_mutex);
+            }
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(METER_READ_INTERVAL_MS));
+    }
+}
+
+void Calibrate_ADE7758(void) {
+    gainSetup(INTEGRATOR_OFF, FULLSCALESELECT_0_5V, GAIN_1, GAIN_1);
+    setupDivs(1, 1, 1);
+    setLcycMode(0x00);
+    resetStatus();
+}
+
+void meter_init(void) {
+    ESP_LOGI(TAG, "Initializing meter");
+
+    if (!meter_mutex) {
+        meter_mutex = xSemaphoreCreateMutex();
+        if (!meter_mutex) {
+            ESP_LOGE(TAG, "Erro ao criar semáforo de mutex");
+            return;  // Pode parar a inicialização caso não consiga criar o mutex
+        }
+    }
+
+    meter_initData();
+    esp_err_t err = Init(EEPROM_HOST, PIN_NUM_MISO, PIN_NUM_MOSI, PIN_NUM_CLK);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Erro na inicialização do hardware SPI: %d", err);
+        return;
+    }
+
+    InitSpi(PIN_NUM_CS);
+}
+
+void meter_start(void) {
+    ESP_LOGI(TAG, "Starting meter");
+
+    Calibrate_ADE7758();
+    meter_initData();
+
+    if (!meter_task) {
+        xTaskCreate(meter_task_func, "meter_task", 5 * 1024, NULL, 5, &meter_task);
+    }
+}
+
+void meter_stop(void) {
+    ESP_LOGI(TAG, "Stopping meter");
+
+    if (meter_task) {
+        vTaskDelete(meter_task);
+        meter_task = NULL;
+    }
+
+    meter_initData();
+}