Ir al contenido

← Modos del router | Contenido | Siguiente: Aplicación principal →

5. APIs de módulos y estructuras de datos



5.1 API RouterController

Archivos:
- components/acrouter_hal/include/RouterController.h
- components/acrouter_hal/src/RouterController.cpp

Patrón de diseño: Singleton


Obtener instancia

cpp
RouterController& router = RouterController::getInstance();


Inicialización

begin()

cpp
bool begin(DimmerHAL* dimmer, DimmerChannel channel = DimmerChannel::CHANNEL_1);

Descripción: Inicializar el controlador con vinculación al dimmer.

Parameters:
- dimmer - pointer to initialized DimmerHAL
- channel - dimmer channel (CHANNEL_1 or CHANNEL_2)

Retorna: true en caso de éxito, false en caso de error

Ejemplo:

cpp
DimmerHAL& dimmer = DimmerHAL::getInstance();
RouterController& router = RouterController::getInstance();

dimmer.begin();
if (router.begin(&dimmer, DimmerChannel::CHANNEL_1)) {
    Serial.println("RouterController initialized");
} else {
    Serial.println("RouterController init failed");
}


Gestión de modos

setMode()

cpp
void setMode(RouterMode mode);

Descripción: Establecer el modo de funcionamiento del controlador.

Parameters:
- mode - one of 6 modes (OFF=0, AUTO=1, ECO=2, OFFGRID=3, MANUAL=4, BOOST=5)

Ejemplo:

cpp
router.setMode(RouterMode::AUTO);    // Automatic mode
router.setMode(RouterMode::MANUAL);  // Manual mode

getMode()

cpp
RouterMode getMode() const;

Descripción: Obtener el modo de funcionamiento actual.

Retorna: RouterMode actual

Ejemplo:

cpp
RouterMode current = router.getMode();
if (current == RouterMode::AUTO) {
    Serial.println("Running in AUTO mode");
}


Parámetros de control

setControlGain()

cpp
void setControlGain(float gain);

Descripción: Establecer el coeficiente proporcional del controlador (Kp).

Parameters:
- gain - gain coefficient (10.0 - 1000.0)

Effect:
- Lower Kp � faster response, possible oscillations
- Higher Kp � slower response, more stable

Ejemplo:

cpp
router.setControlGain(200.0f);  // Standard value
router.setControlGain(100.0f);  // Faster response
router.setControlGain(400.0f);  // Slower, more stable

getControlGain()

cpp
float getControlGain() const;

Retorna: Valor Kp actual

setBalanceThreshold()

cpp
void setBalanceThreshold(float threshold);

Descripción: Establecer el umbral de equilibrio en Watts.

Parameters:
- threshold - threshold in W (typically 5.0 - 50.0)

Effect:
- If |P_grid| < threshold, system is considered balanced
- Lower threshold � more accurate balance, more switching
- Higher threshold � less switching, less accurate balance

Ejemplo:

cpp
router.setBalanceThreshold(10.0f);  // �10 W considered balanced
router.setBalanceThreshold(20.0f);  // �20 W for larger loads

getBalanceThreshold()

cpp
float getBalanceThreshold() const;

Retorna: Umbral de equilibrio actual (W)


Control manual (modo MANUAL)

setManualLevel()

cpp
void setManualLevel(uint8_t percent);

Descripción: Establecer nivel fijo del dimmer para el modo MANUAL.

Parameters:
- percent - dimmer level 0-100%

Ejemplo:

cpp
router.setMode(RouterMode::MANUAL);
router.setManualLevel(75);  // Set to 75%

getManualLevel()

cpp
uint8_t getManualLevel() const;

Retorna: Nivel establecido para el modo MANUAL


Bucle de actualización principal

update()

cpp
void update(const PowerMeterADC::Measurements& measurements);

Descripción: Función de control principal. Se llama automáticamente desde el callback de PowerMeterADC cada 200 ms.

Parameters:
- measurements - structure with power measurements

Nota: Generalmente se llama de forma automática, no es necesario llamarla manualmente.

Lógica interna:

cpp
void update(const Measurements& meas) {
    switch (mode) {
        case OFF:     processOffMode();           break;
        case AUTO:    processAutoMode(P_grid);    break;
        case ECO:     processEcoMode(P_grid);     break;
        case OFFGRID: processOffgridMode(meas);   break;
        case MANUAL:  processManualMode();        break;
        case BOOST:   processBoostMode();         break;
    }
}


Parada de emergencia

emergencyStop()

cpp
void emergencyStop();

Descripción: Apagado inmediato del dimmer (0%) y transición al modo OFF.

When to use:
- System overheating
- Sensor error
- Critical situation

Ejemplo:

cpp
if (temperature > 80.0f) {
    router.emergencyStop();
    Serial.println("EMERGENCY STOP: Overheating!");
}


Obtener estado

getStatus()

cpp
RouterStatus getStatus() const;

Descripción: Obtener información completa del estado del controlador.

Retorna: Estructura RouterStatus

Ejemplo:

cpp
RouterStatus status = router.getStatus();

Serial.printf("Mode: %d\n", static_cast(status.mode));
Serial.printf("State: %d\n", static_cast(status.state));
Serial.printf("Dimmer: %d%%\n", status.dimmer_percent);
Serial.printf("P_grid: %.1f W\n", status.power_grid);
Serial.printf("Kp: %.1f\n", status.control_gain);


Estructuras de datos

RouterStatus

cpp
struct RouterStatus {
    RouterMode mode;                    // Current mode
    RouterState state;                  // State (IDLE, INCREASING, etc.)
    uint8_t dimmer_percent;             // Dimmer level (0-100%)
    float target_level;                 // Target level (float for smoothness)
    float power_grid;                   // Current grid power (W)
    float control_gain;                 // Kp coefficient
    float balance_threshold;            // Balance threshold (W)
    uint32_t last_update_ms;            // Last update timestamp
    bool valid;                         // Status is valid
};

RouterMode

cpp
enum class RouterMode : uint8_t {
    OFF = 0,        // Disabled
    AUTO,           // Automatic Solar Router
    ECO,            // Economic (anti-export)
    OFFGRID,        // Autonomous
    MANUAL,         // Manual
    BOOST           // Forced 100%
};

RouterState

cpp
enum class RouterState : uint8_t {
    IDLE,           // No action
    INCREASING,     // Increasing dimmer (exporting)
    DECREASING,     // Decreasing dimmer (importing)
    AT_MAXIMUM,     // At maximum (100%)
    AT_MINIMUM,     // At minimum (0%)
    ERROR           // Error state
};



5.2 API PowerMeterADC

Archivos:
- components/acrouter_hal/include/PowerMeterADC.h
- components/acrouter_hal/src/PowerMeterADC.cpp

Patrón de diseño: Singleton


Obtener instancia

cpp
PowerMeterADC& powerMeter = PowerMeterADC::getInstance();


Inicialización

begin()

cpp
bool begin();

Descripción: Inicializar DMA ADC y crear tarea de procesamiento FreeRTOS.

Retorna: true en caso de éxito

Ejemplo:

cpp
PowerMeterADC& powerMeter = PowerMeterADC::getInstance();

if (powerMeter.begin()) {
    Serial.println("PowerMeterADC initialized");
} else {
    Serial.println("PowerMeterADC init failed");
}


Control de mediciones

start()

cpp
bool start();

Descripción: Iniciar mediciones DMA ADC continuas.

Retorna: true si se inició con éxito

Ejemplo:

cpp
if (powerMeter.start()) {
    Serial.println("Measurements started");
}

stop()

cpp
void stop();

Descripción: Detener las mediciones.

Ejemplo:

cpp
powerMeter.stop();
Serial.println("Measurements stopped");

isRunning()

cpp
bool isRunning() const;

Descripción: Verificar si las mediciones están en ejecución.

Retorna: true si las mediciones están activas


Callback de resultados

setCallback()

cpp
void setCallback(std::function callback);

Descripción: Establecer la función callback que se llama cada 200 ms con los resultados RMS.

Parameters:
- callback - function of type void callback(const Measurements& meas)

Ejemplo:

cpp
// Option 1: Lambda
powerMeter.setCallback([](const PowerMeterADC::Measurements& meas) {
    Serial.printf("V: %.1f V, I_grid: %.2f A, P_grid: %.1f W\n",
                  meas.voltage_rms,
                  meas.current_rms[PowerMeterADC::CURRENT_GRID],
                  meas.power_active[PowerMeterADC::CURRENT_GRID]);
});

// Option 2: Global function
void onMeasurements(const PowerMeterADC::Measurements& meas) {
    // Process measurements
}
powerMeter.setCallback(onMeasurements);

// Option 3: Class method
powerMeter.setCallback([this](const auto& meas) {
    this->handleMeasurements(meas);
});


Calibración de sensores

setVoltageCalibration()

cpp
void setVoltageCalibration(float multiplier, float offset = 0.0f);

Descripción: Establecer coeficientes de calibración para el sensor de voltaje.

Parameters:
- multiplier - multiplier (V/V_adc)
- offset - offset (V)

Fórmula: V_real = V_adc * multiplier + offset

Ejemplo:

cpp
// ZMPT107: 230V � 1V (scale 1:230)
powerMeter.setVoltageCalibration(230.0f, 0.0f);

// With offset correction
powerMeter.setVoltageCalibration(235.0f, -2.5f);

setCurrentCalibration()

cpp
void setCurrentCalibration(CurrentChannel channel, float multiplier, float offset = 0.0f);

Descripción: Establecer coeficientes de calibración para el sensor de corriente.

Parameters:
- channel - channel (CURRENT_LOAD, CURRENT_GRID, CURRENT_SOLAR)
- multiplier - multiplier (A/V_adc)
- offset - offset (A)

Fórmula: I_real = I_adc * multiplier + offset

Ejemplo:

cpp
// SCT-013-030: 30A � 1V
powerMeter.setCurrentCalibration(PowerMeterADC::CURRENT_GRID, 30.0f, 0.0f);

// ACS-712-20A: 0A=2.5V, sensitivity 100mV/A
powerMeter.setCurrentCalibration(PowerMeterADC::CURRENT_LOAD, 10.0f, -25.0f);


Obtener datos

getPowerData()

cpp
Measurements getPowerData() const;

Descripción: Obtener las últimas mediciones (thread-safe).

Retorna: Estructura Measurements

Ejemplo:

cpp
PowerMeterADC::Measurements data = powerMeter.getPowerData();

if (data.valid) {
    Serial.printf("Voltage: %.1f V\n", data.voltage_rms);
    Serial.printf("Current Grid: %.2f A\n", data.current_rms[PowerMeterADC::CURRENT_GRID]);
    Serial.printf("Power Grid: %.1f W\n", data.power_active[PowerMeterADC::CURRENT_GRID]);
}

getVoltageRMS()

cpp
float getVoltageRMS() const;

Descripción: Obtener solo el voltaje RMS.

Retorna: Voltaje en Voltios

getCurrentRMS()

cpp
float getCurrentRMS(CurrentChannel channel) const;

Descripción: Obtener la corriente RMS para el canal especificado.

Parameters:
- channel - CURRENT_LOAD, CURRENT_GRID or CURRENT_SOLAR

Retorna: Corriente en Amperios

Ejemplo:

cpp
float i_grid = powerMeter.getCurrentRMS(PowerMeterADC::CURRENT_GRID);
float i_solar = powerMeter.getCurrentRMS(PowerMeterADC::CURRENT_SOLAR);

Serial.printf("Grid: %.2f A, Solar: %.2f A\n", i_grid, i_solar);

getPower()

cpp
float getPower(CurrentChannel channel) const;

Descripción: Obtener la potencia activa para el canal especificado.

Parameters:
- channel - CURRENT_LOAD, CURRENT_GRID or CURRENT_SOLAR

Retorna: Potencia en Watts

Ejemplo:

cpp
float p_grid = powerMeter.getPower(PowerMeterADC::CURRENT_GRID);

if (p_grid < 0) {
    Serial.println("Exporting to grid");
} else {
    Serial.println("Importing from grid");
}


Estructuras de datos

Measurements

cpp
struct Measurements {
    float voltage_rms;                  // RMS voltage (V)
    float current_rms[3];               // RMS currents [LOAD, GRID, SOLAR] (A)
    float power_active[3];              // Active power [LOAD, GRID, SOLAR] (W)
    float power_reactive[3];            // Reactive power (VAR) - Phase 2
    float power_apparent[3];            // Apparent power (VA) - Phase 2
    float power_factor[3];              // Power factor - Phase 2
    uint32_t timestamp_ms;              // Timestamp
    bool valid;                         // Data is valid
};

CurrentChannel

cpp
enum CurrentChannel : uint8_t {
    CURRENT_LOAD = 0,    // Load current (dimmer)
    CURRENT_GRID = 1,    // Grid current (import/export)
    CURRENT_SOLAR = 2,   // Solar panel current
    CURRENT_COUNT = 3
};



5.3 API DimmerHAL

Archivos:
- components/acrouter_hal/include/DimmerHAL.h
- components/acrouter_hal/src/DimmerHAL.cpp

Patrón de diseño: Singleton


Obtener instancia

cpp
DimmerHAL& dimmer = DimmerHAL::getInstance();


Inicialización

begin()

cpp
bool begin();

Descripción: Inicializar el dimmer con detector de cruce por cero.

Retorna: true en caso de éxito

Ejemplo:

cpp
DimmerHAL& dimmer = DimmerHAL::getInstance();

if (dimmer.begin()) {
    Serial.println("DimmerHAL initialized");
} else {
    Serial.println("DimmerHAL init failed");
}


Control de potencia

setPower()

cpp
void setPower(DimmerChannel channel, uint8_t percent);

Descripción: Establecer la potencia del dimmer instantáneamente.

Parameters:
- channel - CHANNEL_1 or CHANNEL_2
- percent - power 0-100%

Ejemplo:

cpp
dimmer.setPower(DimmerChannel::CHANNEL_1, 75);  // 75%
dimmer.setPower(DimmerChannel::CHANNEL_2, 50);  // 50% on second channel

setPowerSmooth()

cpp
void setPowerSmooth(DimmerChannel channel, uint8_t percent, uint32_t transition_ms);

Descripción: Establecer la potencia con transición suave.

Parameters:
- channel - CHANNEL_1 or CHANNEL_2
- percent - target power 0-100%
- transition_ms - transition time in milliseconds

Ejemplo:

cpp
// Smoothly transition to 80% over 2 seconds
dimmer.setPowerSmooth(DimmerChannel::CHANNEL_1, 80, 2000);

// Smooth shutdown over 1 second
dimmer.setPowerSmooth(DimmerChannel::CHANNEL_1, 0, 1000);

getPower()

cpp
uint8_t getPower(DimmerChannel channel) const;

Descripción: Obtener la potencia actual del canal.

Retorna: Potencia 0-100%

Ejemplo:

cpp
uint8_t current_power = dimmer.getPower(DimmerChannel::CHANNEL_1);
Serial.printf("Dimmer 1: %d%%\n", current_power);


Control rápido

turnOff()

cpp
void turnOff(DimmerChannel channel);

Descripción: Apagar rápidamente un canal (0%).

Ejemplo:

cpp
dimmer.turnOff(DimmerChannel::CHANNEL_1);

turnOffAll()

cpp
void turnOffAll();

Descripción: Apagar todos los canales.

Ejemplo:

cpp
dimmer.turnOffAll();  // Emergency shutdown


Curva de potencia

setCurve()

cpp
void setCurve(DimmerChannel channel, DimmerCurve curve);

Descripción: Establecer el tipo de curva de potencia.

Parameters:
- channel - CHANNEL_1 or CHANNEL_2
- curve - LINEAR, RMS or LOGARITHMIC

Recommendations:
- RMS - for resistive loads (heaters, water heaters) - recommended
- LINEAR - linear dependency
- LOGARITHMIC - for LED lamps

Ejemplo:

cpp
// RMS curve for heater (recommended)
dimmer.setCurve(DimmerChannel::CHANNEL_1, DimmerCurve::RMS);

// Linear curve
dimmer.setCurve(DimmerChannel::CHANNEL_1, DimmerCurve::LINEAR);


Estado e información

getStatus()

cpp
DimmerStatus getStatus(DimmerChannel channel) const;

Descripción: Obtener el estado detallado del canal.

Retorna: Estructura DimmerStatus

Ejemplo:

cpp
DimmerStatus status = dimmer.getStatus(DimmerChannel::CHANNEL_1);

Serial.printf("Initialized: %s\n", status.initialized ? "Yes" : "No");
Serial.printf("Active: %s\n", status.active ? "Yes" : "No");
Serial.printf("Power: %d%%\n", status.power_percent);
Serial.printf("Target: %d%%\n", status.target_percent);

isInitialized()

cpp
bool isInitialized() const;

Descripción: Verificar si el dimmer está inicializado.

Retorna: true si está inicializado


Estructuras de datos

DimmerChannel

cpp
enum class DimmerChannel : uint8_t {
    CHANNEL_1 = 0,      // First channel (GPIO 19)
    CHANNEL_2 = 1       // Second channel (GPIO 23)
};

DimmerCurve

cpp
enum class DimmerCurve : uint8_t {
    LINEAR,         // Linear
    RMS,            // RMS-compensated (recommended)
    LOGARITHMIC     // Logarithmic
};

DimmerStatus

cpp
struct DimmerStatus {
    bool initialized;           // Initialized
    bool active;                // Active
    uint8_t power_percent;      // Current power (0-100%)
    uint8_t target_percent;     // Target power (during transition)
    DimmerCurve curve;          // Curve type
    uint32_t last_update_ms;    // Last update time
};



5.4 API ConfigManager

Archivos:
- components/utils/include/ConfigManager.h
- components/utils/src/ConfigManager.cpp

Patrón de diseño: Singleton

Espacio de nombres NVS: "acrouter"


Obtener instancia

cpp
ConfigManager& config = ConfigManager::getInstance();


Inicialización

begin()

cpp
bool begin();

Descripción: Inicializar NVS y cargar la configuración.

Retorna: true en caso de éxito

Ejemplo:

cpp
ConfigManager& config = ConfigManager::getInstance();

if (config.begin()) {
    Serial.println("ConfigManager initialized");
    Serial.printf("Router mode: %d\n", config.getConfig().router_mode);
}


Obtener configuración

getConfig()

cpp
const SystemConfig& getConfig() const;

Descripción: Obtener referencia a la configuración actual.

Retorna: Referencia const a SystemConfig

Ejemplo:

cpp
const SystemConfig& cfg = config.getConfig();

Serial.printf("Mode: %d\n", cfg.router_mode);
Serial.printf("Kp: %.1f\n", cfg.control_gain);
Serial.printf("Threshold: %.1f W\n", cfg.balance_threshold);


Establecer parámetros

setRouterMode()

cpp
bool setRouterMode(uint8_t mode);

Descripción: Establecer el modo del router (se guarda automáticamente en NVS).

Parameters:
- mode - mode 0-5

Retorna: true si se guardó con éxito

Ejemplo:

cpp
config.setRouterMode(1);  // AUTO mode

setControlGain()

cpp
bool setControlGain(float gain);

Descripción: Establecer el coeficiente Kp.

Parameters:
- gain - coefficient (10.0 - 1000.0)

Ejemplo:

cpp
config.setControlGain(200.0f);

setBalanceThreshold()

cpp
bool setBalanceThreshold(float threshold);

Descripción: Establecer el umbral de equilibrio.

Parameters:
- threshold - threshold in Watts (0.0 - 100.0)

Ejemplo:

cpp
config.setBalanceThreshold(10.0f);

setManualLevel()

cpp
bool setManualLevel(uint8_t level);

Descripción: Establecer el nivel para el modo MANUAL.

Parameters:
- level - level 0-100%

Ejemplo:

cpp
config.setManualLevel(75);

setVoltageCoefficient()

cpp
bool setVoltageCoefficient(float coef);

Descripción: Establecer el coeficiente de calibración de voltaje.

Ejemplo:

cpp
config.setVoltageCoefficient(230.0f);

setCurrentCoefficient()

cpp
bool setCurrentCoefficient(float coef);

Descripción: Establecer el coeficiente de calibración de corriente.

Ejemplo:

cpp
config.setCurrentCoefficient(30.0f);  // SCT-013-030


Operaciones por lotes

saveAll()

cpp
bool saveAll();

Descripción: Guardar todos los parámetros en NVS.

Nota: Generalmente no es necesario ya que cada método set*() guarda automáticamente.

loadAll()

cpp
bool loadAll();

Descripción: Recargar la configuración desde NVS.

resetToDefaults()

cpp
bool resetToDefaults();

Descripción: Restablecer todos los ajustes a los valores de fábrica y guardar en NVS.

Ejemplo:

cpp
if (config.resetToDefaults()) {
    Serial.println("Config reset to defaults");
}


Estructuras de datos

SystemConfig

cpp
struct SystemConfig {
    // Router parameters
    uint8_t router_mode;        // RouterMode (0-5)
    float control_gain;         // Kp (10.0 - 1000.0)
    float balance_threshold;    // Balance threshold (W)
    uint8_t manual_level;       // MANUAL level (0-100%)

    // Sensor calibration
    float voltage_coef;         // Voltage coefficient
    float current_coef;         // Current coefficient (A/V)
    float current_threshold;    // Minimum current (A)
    float power_threshold;      // Minimum power (W)
};



5.5 API HardwareConfigManager

Archivos:
- components/utils/include/HardwareConfigManager.h
- components/utils/src/HardwareConfigManager.cpp

Patrón de diseño: Singleton

Espacio de nombres NVS: "hw_config"


Obtener instancia

cpp
HardwareConfigManager& hwConfig = HardwareConfigManager::getInstance();


Inicialización

begin()

cpp
bool begin();

Descripción: Inicializar y cargar la configuración de hardware desde NVS.

Ejemplo:

cpp
HardwareConfigManager& hwConfig = HardwareConfigManager::getInstance();

if (hwConfig.begin()) {
    Serial.println("HardwareConfigManager initialized");
}


Configuración de canales ADC

setADCChannel()

cpp
bool setADCChannel(uint8_t channel, const ADCChannelConfig& config);

Descripción: Configurar un canal ADC.

Parameters:
- channel - channel number (0-3)
- config - channel configuration

Retorna: true en caso de éxito

Ejemplo:

cpp
ADCChannelConfig voltage_cfg;
voltage_cfg.gpio = 35;
voltage_cfg.type = SensorType::VOLTAGE_AC;
voltage_cfg.multiplier = 230.0f;
voltage_cfg.offset = 0.0f;
voltage_cfg.enabled = true;

hwConfig.setADCChannel(0, voltage_cfg);

getADCChannel()

cpp
ADCChannelConfig getADCChannel(uint8_t channel) const;

Descripción: Obtener la configuración de un canal ADC.

Ejemplo:

cpp
ADCChannelConfig cfg = hwConfig.getADCChannel(0);
Serial.printf("ADC0: GPIO%d, Type=%d, Mult=%.1f\n",
              cfg.gpio, static_cast(cfg.type), cfg.multiplier);


Configuración del dimmer

setDimmerChannel()

cpp
bool setDimmerChannel(uint8_t channel, const DimmerChannelConfig& config);

Descripción: Configurar un canal del dimmer.

Parameters:
- channel - 0 (Channel 1) or 1 (Channel 2)
- config - configuration

Ejemplo:

cpp
DimmerChannelConfig dim_cfg;
dim_cfg.gpio = 19;
dim_cfg.enabled = true;

hwConfig.setDimmerChannel(0, dim_cfg);


Configuración del cruce por cero

setZeroCross()

cpp
bool setZeroCross(uint8_t gpio, bool enabled = true);

Descripción: Configurar el pin del detector de cruce por cero.

Ejemplo:

cpp
hwConfig.setZeroCross(18, true);  // GPIO18, enabled


Configuración de relés

setRelayChannel()

cpp
bool setRelayChannel(uint8_t channel, const RelayChannelConfig& config);

Descripción: Configurar un canal de relé.

Parameters:
- channel - 0 or 1
- config - relay configuration

Ejemplo:

cpp
RelayChannelConfig relay_cfg;
relay_cfg.gpio = 15;
relay_cfg.active_high = true;  // Active HIGH
relay_cfg.enabled = true;

hwConfig.setRelayChannel(0, relay_cfg);


Configuración de LEDs

setStatusLED()

cpp
bool setStatusLED(uint8_t gpio);

Descripción: Configurar el GPIO para el LED de estado.

Ejemplo:

cpp
hwConfig.setStatusLED(17);

setLoadLED()

cpp
bool setLoadLED(uint8_t gpio);

Descripción: Configurar el GPIO para el LED indicador de carga.


Validación

validate()

cpp
bool validate(String* error_msg = nullptr) const;

Descripción: Validar la configuración en busca de errores.

Parameters:
- error_msg - pointer to String for error message (optional)

Retorna: true si la configuración es válida

Checks:
- GPIO conflicts (one pin = one function)
- Pin validity for ADC (ADC1 only: 32-39)
- Input-only pins (34,35,36,39 cannot be outputs)

Ejemplo:

cpp
String error;
if (!hwConfig.validate(&error)) {
    Serial.printf("Validation failed: %s\n", error.c_str());
} else {
    Serial.println("Configuration is valid");
}


Operaciones por lotes

saveAll()

cpp
bool saveAll();

Descripción: Guardar toda la configuración en NVS.

loadAll()

cpp
bool loadAll();

Descripción: Cargar la configuración desde NVS.

resetToDefaults()

cpp
bool resetToDefaults();

Descripción: Restablecer a valores de fábrica.

printConfig()

cpp
void printConfig() const;

Descripción: Imprimir la configuración por Serial.

Ejemplo:

cpp
hwConfig.printConfig();
// Output:
// === Hardware Configuration ===
// ADC0: GPIO35, VOLTAGE_AC, mult=230.0, enabled
// ADC1: GPIO39, CURRENT_LOAD, mult=30.0, enabled
// ...


Estructuras de datos

ADCChannelConfig

cpp
struct ADCChannelConfig {
    uint8_t gpio;               // GPIO pin (32-39 for ADC1)
    SensorType type;            // Sensor type
    float multiplier;           // Calibration multiplier
    float offset;               // Offset
    bool enabled;               // Channel enabled
};

DimmerChannelConfig

cpp
struct DimmerChannelConfig {
    uint8_t gpio;               // GPIO pin
    bool enabled;               // Channel enabled
};

RelayChannelConfig

cpp
struct RelayChannelConfig {
    uint8_t gpio;               // GPIO pin
    bool active_high;           // true=Active HIGH, false=Active LOW
    bool enabled;               // Channel enabled
};

SensorType

cpp
enum class SensorType : uint8_t {
    NONE = 0,           // Not used
    VOLTAGE_AC,         // ZMPT107 (AC voltage)
    CURRENT_LOAD,       // ACS-712 (dimmer load current)
    CURRENT_GRID,       // SCT-013 (grid current)
    CURRENT_SOLAR,      // SCT-013 (solar current)
    CURRENT_AUX1,       // Auxiliary channel 1
    CURRENT_AUX2        // Auxiliary channel 2
};



5.6 API WiFiManager

Archivos:
- components/comm/include/WiFiManager.h
- components/comm/src/WiFiManager.cpp

Patrón de diseño: Singleton


Obtener instancia

cpp
WiFiManager& wifi = WiFiManager::getInstance();


Inicialización

begin()

cpp
bool begin();

Descripción: Inicializar WiFi. Inicia automáticamente el AP si no hay credenciales STA.

Retorna: true en caso de éxito

Ejemplo:

cpp
WiFiManager& wifi = WiFiManager::getInstance();

if (wifi.begin()) {
    Serial.println("WiFiManager initialized");

    WiFiStatus status = wifi.getStatus();
    Serial.printf("AP IP: %s\n", status.ap_ip.toString().c_str());
}


Modo AP

startAP()

cpp
bool startAP(const char* ssid = nullptr, const char* password = nullptr);

Descripción: Iniciar punto de acceso.

Parameters:
- ssid - network SSID (nullptr = auto: "ACRouter_XXXXXX")
- password - password (nullptr = "12345678")

Ejemplo:

cpp
// With auto-generated SSID
wifi.startAP();

// With custom SSID
wifi.startAP("MyACRouter", "mypassword123");

stopAP()

cpp
void stopAP();

Descripción: Detener punto de acceso.

isAPActive()

cpp
bool isAPActive() const;

Retorna: true si el AP está activo


Modo STA

connectSTA()

cpp
bool connectSTA(const char* ssid, const char* password);

Descripción: Conectar a una red WiFi.

Parameters:
- ssid - network SSID
- password - password

Retorna: true si está conectado

Ejemplo:

cpp
if (wifi.connectSTA("HomeNetwork", "password123")) {
    Serial.println("Connected to WiFi");

    WiFiStatus status = wifi.getStatus();
    Serial.printf("STA IP: %s\n", status.sta_ip.toString().c_str());
}

disconnectSTA()

cpp
void disconnectSTA();

Descripción: Desconectar de la red STA.

isSTAConnected()

cpp
bool isSTAConnected() const;

Retorna: true si está conectado a STA


Escaneo de redes

scanNetworks()

cpp
std::vector scanNetworks();

Descripción: Escanear redes WiFi disponibles.

Retorna: Vector de estructuras WiFiNetwork

Ejemplo:

cpp
std::vector networks = wifi.scanNetworks();

Serial.printf("Found %d networks:\n", networks.size());
for (const auto& net : networks) {
    Serial.printf("  %s (RSSI: %d, Encrypted: %s)\n",
                  net.ssid.c_str(),
                  net.rssi,
                  net.encrypted ? "Yes" : "No");
}


Estado

getStatus()

cpp
WiFiStatus getStatus() const;

Descripción: Obtener el estado WiFi completo.

Ejemplo:

cpp
WiFiStatus status = wifi.getStatus();

Serial.printf("State: %d\n", static_cast(status.state));
Serial.printf("STA connected: %s\n", status.sta_connected ? "Yes" : "No");
Serial.printf("AP active: %s\n", status.ap_active ? "Yes" : "No");

if (status.sta_connected) {
    Serial.printf("STA IP: %s\n", status.sta_ip.toString().c_str());
    Serial.printf("RSSI: %d dBm\n", status.rssi);
}

if (status.ap_active) {
    Serial.printf("AP IP: %s\n", status.ap_ip.toString().c_str());
    Serial.printf("Clients: %d\n", status.sta_clients);
}


Estructuras de datos

WiFiState

cpp
enum class WiFiState : uint8_t {
    IDLE,               // Not initialized
    AP_ONLY,            // AP only
    STA_CONNECTING,     // Connecting to STA
    STA_CONNECTED,      // Connected to STA
    AP_STA,             // Both modes
    STA_FAILED          // STA failed
};

WiFiStatus

cpp
struct WiFiStatus {
    WiFiState state;
    bool sta_connected;
    bool ap_active;
    IPAddress sta_ip;
    IPAddress ap_ip;
    String sta_ssid;
    String ap_ssid;
    int8_t rssi;
    uint8_t sta_clients;        // Clients on AP
};

WiFiNetwork

cpp
struct WiFiNetwork {
    String ssid;
    int8_t rssi;
    bool encrypted;
};



5.7 API WebServerManager

Archivos:
- components/comm/include/WebServerManager.h
- components/comm/src/WebServerManager.cpp

Patrón de diseño: Singleton


Obtener instancia

cpp
WebServerManager& webServer = WebServerManager::getInstance();


Inicialización

begin()

cpp
bool begin(uint16_t http_port = 80);

Descripción: Inicializar el servidor HTTP.

Parameters:
- http_port - HTTP port (default 80)

Ejemplo:

cpp
WebServerManager& webServer = WebServerManager::getInstance();

if (webServer.begin(80)) {
    Serial.println("WebServer started on port 80");
}


Control

start()

cpp
void start();

Descripción: Iniciar el servidor web.

stop()

cpp
void stop();

Descripción: Detener el servidor web.

isRunning()

cpp
bool isRunning() const;

Retorna: true si el servidor está en ejecución


Procesamiento de solicitudes

handleClient()

cpp
void handleClient();

Descripción: Procesar las solicitudes HTTP entrantes. Llamar desde loop().

Ejemplo:

cpp
void loop() {
    webServer.handleClient();
    // ... rest of code
}


Puntos finales REST API

Para la lista completa de puntos finales, consulte Sección 8: Puntos finales GET y Sección 9: Puntos finales POST.

Grupos principales:

  • Páginas web: /, /wifi, /settings/hardware
  • Estado: /api/status, /api/metrics, /api/config
  • Control: /api/mode, /api/manual, /api/calibrate
  • WiFi: /api/wifi/*
  • Hardware: /api/hardware/*
  • Sistema: /api/system/reboot

← Modos del router | Contenido | Siguiente: Aplicación principal →

5.1 API RouterController 5.2 API PowerMeterADC 5.3 API DimmerHAL 5.4 API ConfigManager 5.5 API HardwareConfigManager 5.6 API WiFiManager 5.7 API WebServerManager