rbgrid

/**
 * @file basic_app.cpp
 * @brief Basic application example with sensor initialization and terminal output
 */

#include "Arduino.h"
#include "rbgrid.h"
#include "rbtelemetry.h"
#include "rbgrid.h"
#include "rbgrid_config_api.h"
#include "esp_timer.h"
#include "driver/gpio.h"

// ====== PINS ======
#define ZC_CROSS_PIN          18    // GPIO18 for Zero Cross

// ====== GLOBAL VARIABLES ======
rbgrid_unit_uid_t voltage_sensor_uid;
rbgrid_unit_uid_t current_sensor_uid;
rbgrid_unit_uid_t alt_sensor_uid;
rbgrid_unit_uid_t heater_sensor_uid;

static rbgrid_extended_config_t* g_extended_config = NULL;

// Forward declaration for access to internal structures
struct rbgrid_config_context_s {
    rbgrid_extended_config_t* extended_config;
    rbgrid_hardware_config_t* hardware_config;
    rbgrid_electrical_network_t* network;
    rbgrid_unit_definition_t* units_array;
    uint16_t units_allocated;
    uint16_t units_count;
    struct {
        int next_sensor_id;
        int next_unit_id;
        uint8_t adc_channels_used;
        bool has_zc_sensor;
        bool has_voltage_bus;
        bool has_main_supply;
        bool has_alternative_supply;
    } builder;
    struct {
        bool base_initialized;
        bool network_configured;
        bool sensors_configured;
        bool units_configured;
    } status;
    bool is_initialized;
    bool is_applied;
};
typedef struct rbgrid_config_context_s rbgrid_config_context_t;

// ====== SETUP ======
void setup() {
    Serial.begin(115200);
    Serial.println("\n=== Basic rbgrid example ===");

    // Reset ADC pins
    gpio_reset_pin(GPIO_NUM_33);
    gpio_reset_pin(GPIO_NUM_34);
    gpio_set_direction(GPIO_NUM_33, GPIO_MODE_INPUT);
    gpio_set_direction(GPIO_NUM_34, GPIO_MODE_INPUT);
    gpio_set_pull_mode(GPIO_NUM_33, GPIO_FLOATING);
    gpio_set_pull_mode(GPIO_NUM_34, GPIO_FLOATING);

    // Create configuration via API
    rbgrid_config_handle_t config_handle = rbgrid_config_create("Test House", "HongKong");
    if (!config_handle) {
        Serial.println("ERROR: Failed to create configuration");
        return;
    }

    // Configure network
    int config_err = rbgrid_config_set_configuration(config_handle);
    if (config_err != RBGRID_CONFIG_OK) {
        Serial.print("ERROR: Failed to configure network: ");
        Serial.println(config_err);
        rbgrid_config_destroy(config_handle);
        return;
    }

    // Get pointers to internal structures
    rbgrid_config_context_t* config_ctx = (rbgrid_config_context_t*)config_handle;
    rbgrid_extended_config_t* extended_config = config_ctx->extended_config;
    rbgrid_hardware_config_t* base_hardware_config = config_ctx->hardware_config;

    // Network frequency configuration
    base_hardware_config->network.nominal_frequency = 50;

    // Add voltage sensor ZMPT107-1 on GPIO35
    voltage_sensor_uid = rbgrid_config_add_adc_sensor(config_handle, GPIO_NUM_35, RBSENSOR_TYPE_VOLTAGE_ZMPT107_1);
    if (voltage_sensor_uid == RBGRID_INVALID_UNIT_UID) {
        Serial.println("ERROR: Failed to add voltage sensor");
    } else {
        Serial.print("Voltage sensor added, UID: 0x");
        Serial.println(voltage_sensor_uid, HEX);
    }

    // Add current sensor SCT013-10A on GPIO34
    current_sensor_uid = rbgrid_config_add_adc_sensor(config_handle, GPIO_NUM_34, RBSENSOR_TYPE_CURRENT_SCT013_10A);
    if (current_sensor_uid == RBGRID_INVALID_UNIT_UID) {
        Serial.println("ERROR: Failed to add main current sensor");
    } else {
        Serial.print("Main current sensor added, UID: 0x");
        Serial.println(current_sensor_uid, HEX);
    }

    // Add current sensor SCT013-50A on GPIO33
    alt_sensor_uid = rbgrid_config_add_adc_sensor(config_handle, GPIO_NUM_33, RBSENSOR_TYPE_CURRENT_SCT013_50A);
    if (alt_sensor_uid == RBGRID_INVALID_UNIT_UID) {
        Serial.println("ERROR: Failed to add alternative current sensor");
    } else {
        Serial.print("Alternative current sensor added, UID: 0x");
        Serial.println(alt_sensor_uid, HEX);
    }

    // Add current sensor for heater on GPIO32
    heater_sensor_uid = rbgrid_config_add_adc_sensor(config_handle, GPIO_NUM_32, RBSENSOR_TYPE_CURRENT_SCT013_10A);
    if (heater_sensor_uid == RBGRID_INVALID_UNIT_UID) {
        Serial.println("ERROR: Failed to add heater sensor");
    } else {
        Serial.print("Heater sensor added, UID: 0x");
        Serial.println(heater_sensor_uid, HEX);
    }

    // Add Zero-Cross sensor on GPIO18
    config_err = rbgrid_config_add_zc_sensor(config_handle, (gpio_num_t)ZC_CROSS_PIN);
    if (config_err != RBGRID_CONFIG_OK) {
        Serial.print("ERROR: Failed to add ZC sensor: ");
        Serial.println(config_err);
    } else {
        Serial.print("Zero-Cross sensor configured on GPIO");
        Serial.println(ZC_CROSS_PIN);

        // Initialize ZC
        rbgrid_zc_config_t zc_config = RBPOWER_ZC_DEFAULT_CONFIG((rbgrid_gpio_t)ZC_CROSS_PIN);
        rbgrid_err_t zc_err = rbgrid_init_zc(&zc_config);
        if (zc_err != RBPOWER_OK) {
            Serial.print("ERROR: ZC init failed: ");
            Serial.println((int)zc_err);
        } else {
            delay(200);
            uint16_t measured_freq = rbgrid_get_network_frequency();
            Serial.print("ZC initialized, measured frequency: ");
            Serial.print((int)measured_freq);
            Serial.println("Hz");
            base_hardware_config->network.nominal_frequency = measured_freq;
        }
    }

    // Create Voltage Bus
    if (voltage_sensor_uid != RBGRID_INVALID_UNIT_UID) {
        config_err = rbgrid_config_set_voltage_bus(config_handle, voltage_sensor_uid, "Main Voltage Bus");
        if (config_err != RBGRID_CONFIG_OK) {
            Serial.print("ERROR: Failed to configure voltage bus: ");
            Serial.println(config_err);
        } else {
            Serial.print("Voltage bus configured with UID: 0x");
            Serial.println(voltage_sensor_uid, HEX);
        }
    }

    // Create Main Supply
    if (current_sensor_uid != RBGRID_INVALID_UNIT_UID) {
        config_err = rbgrid_config_set_main_supply(config_handle, current_sensor_uid, "Main Supply", RBPOWER_STAT_PERIOD_1HOUR);
        if (config_err != RBGRID_CONFIG_OK) {
            Serial.print("ERROR: Failed to configure main supply: ");
            Serial.println(config_err);
        } else {
            Serial.print("Main supply configured with UID: 0x");
            Serial.println(current_sensor_uid, HEX);
        }
    }

    // Configure Alternative Supply
    config_err = rbgrid_config_set_alternative_supply(config_handle, alt_sensor_uid, "Alternative Supply", RBPOWER_STAT_PERIOD_1HOUR);
    if (config_err != RBGRID_CONFIG_OK) {
        Serial.print("ERROR: Failed to configure alternative supply: ");
        Serial.println(config_err);
    } else {
        Serial.println("Alternative supply configured");
    }

    // Configure heater
    config_err = rbgrid_config_add_unit(config_handle, heater_sensor_uid, "Heater 10A", RBPOWER_STAT_PERIOD_1HOUR);
    if (config_err != RBGRID_CONFIG_OK) {
        Serial.print("ERROR: Failed to configure heater: ");
        Serial.println(config_err);
    } else {
        Serial.println("Heater configured");
    }

    // Additional settings
    extended_config->rbhome_settings.logging_level = RBGRID_LOG_LEVEL_DEBUG;
    extended_config->enable_time_synchronization = false;
    extended_config->auto_start_measurements = true;

    // Pass units array
    extended_config->units_config.predefined_units = config_ctx->units_array;
    extended_config->units_config.predefined_units_count = config_ctx->units_count;
    extended_config->units_config.use_predefined_only = true;

    g_extended_config = extended_config;

    // Initialize rbgrid system
    Serial.println("Initializing rbgrid system...");
    rbgrid_err_t rbgrid_err = rbgrid_init_hardware();
    if (rbgrid_err != RBGRID_OK) {
        Serial.print("ERROR: rbgrid init failed: ");
        Serial.println(rbgrid_err);
        Serial.println("WARNING: Unit UID mapping features may be limited");
    } else {
        Serial.println("rbgrid system initialized");
    }

    // Initialize rbgrid
    rbgrid_err_t power_err = rbgrid_init_extended(extended_config);
    if (power_err != RBPOWER_OK) {
        Serial.print("ERROR: rbgrid init failed: ");
        Serial.println(power_err);
        Serial.println("WARNING: Continuing with limited functionality");
    }

    Serial.println("\n===== Initialization completed =====");
}

// ====== LOOP ======
void loop() {
    // Print data every 5 seconds
    static unsigned long last_print = millis();

    if (millis() - last_print >= 5000) {
        last_print = millis();

        Serial.println("\n========== Sensor Data ==========");

        // Get voltage statistics
        statistics_3sec_final_t voltage_stats;
        rbgrid_err_t result = rbgrid_realtime_get_voltage(&voltage_stats);

        if (result == RBGRID_OK) {
            Serial.print("Voltage: ");
            Serial.print(voltage_stats.voltage_rms_final, 2);
            Serial.print(" V, Frequency: ");
            Serial.print(voltage_stats.frequency_avg_final, 2);
            Serial.print(" Hz, THD: ");
            Serial.print(voltage_stats.thd_voltage_avg_final, 2);
            Serial.println("%");
        } else {
            Serial.print("ERROR: Failed to get voltage data: ");
            Serial.println(result);
        }

        // Get Main Supply data
        float current_rms, power_active, power_reactive, power_apparent, power_factor, energy_increment;
        uint32_t samples_count;
        rbgrid_current_direction_t direction;

        result = rbgrid_realtime_get_main_supply(¤t_rms, &power_active, &direction,
                                                  &power_reactive, &power_apparent, &power_factor,
                                                  &samples_count, &energy_increment);

        if (result == RBGRID_OK) {
            Serial.print("Main Supply: I=");
            Serial.print(current_rms, 3);
            Serial.print(" A, P=");
            Serial.print(power_active, 1);
            Serial.print(" W, PF=");
            Serial.println(power_factor, 3);
        } else {
            Serial.print("ERROR: Failed to get main supply data: ");
            Serial.println(result);
        }

        // Get Alternative Supply data
        float alt_current_rms, alt_power_active, alt_efficiency, alt_dc_power;
        result = rbgrid_realtime_get_alt_supply(&alt_current_rms, &alt_power_active, &direction,
                                                 &power_reactive, &power_apparent, &power_factor,
                                                 &samples_count, &energy_increment,
                                                 &alt_efficiency, &alt_dc_power);

        if (result == RBGRID_OK) {
            Serial.print("Alt Supply: I=");
            Serial.print(alt_current_rms, 3);
            Serial.print(" A, P=");
            Serial.print(alt_power_active, 1);
            Serial.print(" W, Efficiency=");
            Serial.print(alt_efficiency, 1);
            Serial.println("%");
        } else {
            Serial.print("ERROR: Failed to get alt supply data: ");
            Serial.println(result);
        }

        // Get heater data
        float unit_current, unit_power_active;
        result = rbgrid_realtime_get_unit(heater_sensor_uid, &unit_current, 
                                          &unit_power_active, &power_reactive, 
                                          &power_apparent, &power_factor, 
                                          &samples_count);

        if (result == RBGRID_OK) {
            Serial.print("Heater: I=");
            Serial.print(unit_current, 3);
            Serial.print(" A, P=");
            Serial.print(unit_power_active, 1);
            Serial.print(" W, PF=");
            Serial.println(power_factor, 3);
        } else {
            Serial.print("ERROR: Failed to get heater data: ");
            Serial.println(result);
        }

        Serial.println("=====================================");
    }

    delay(100);
}