getEstimatedPowerInMilliWatts()

fl::u32 CFastLED::getEstimatedPowerInMilliWatts

(

bool

apply_limiter = true

)

const

Get estimated power consumption in milliwatts.

Calculates the estimated power consumption based on current LED buffer contents, brightness setting, and configured power model. This provides visibility into power usage for monitoring and debugging.

Parameters

apply_limiter

If true (default), applies power limiting to calculate actual power. If false, returns requested power before limiting.

Returns

Estimated LED power consumption in milliwatts:

• apply_limiter=true: Power AFTER applying max-power cap (actual power)
• apply_limiter=false: Power BEFORE limiting (requested power)

Note

Usage examples:

fl::u32 actual = FastLED.getEstimatedPowerInMilliWatts();        // With limiting (default)
fl::u32 requested = FastLED.getEstimatedPowerInMilliWatts(false); // Without limiting

When apply_limiter=true:

• If power limiting is NOT enabled, returns unrestricted power
• If power limiting IS enabled, returns power after brightness reduction

MCU power consumption is NOT included in this calculation. Add your platform-specific MCU power separately:

fl::u32 mcu_power_mW = 25 * 5;  // 25mA @ 5V = 125mW (Arduino Uno example)
fl::u32 total_power = FastLED.getEstimatedPowerInMilliWatts() + mcu_power_mW;

Uses the configured power-scaling response. Default is linear scaling; use model.exponent via setPowerModel() or the setPowerScalingExponent() convenience wrapper to enable a non-linear model.

See also

setMaxPowerInMilliWatts()

setPowerModel()

setPowerScalingExponent()

Definition at line 415 of file FastLED.cpp.hpp.

                                                                      {
    fl::u32 total_power_mW = 0;
 
    // Sum unscaled power from all LED controllers using visitor pattern
    CLEDController::visitControllers([&total_power_mW](const CLEDController* /*controller*/, fl::span<const CRGB> leds) {
        if (!leds.empty()) {
            total_power_mW += calculate_unscaled_power_mW(leds);
        }
    });
 
    // Determine effective brightness
    fl::u8 effective_brightness = mScale;
 
    if (apply_limiter && mPPowerFunc) {
        // Power limiting is enabled and user wants limited power - calculate brightness after limiting
        // This calls calculate_max_brightness_for_power_mW(mScale, mNPowerData)
        effective_brightness = (*mPPowerFunc)(mScale, mNPowerData);
    }
 
    // Scale by the configured power-brightness response.
    // Note: MCU power consumption is NOT included - caller should add platform-specific MCU power if needed
    return scale_power_for_brightness(total_power_mW, effective_brightness);
}

References calculate_unscaled_power_mW(), leds(), mNPowerData, mPPowerFunc, mScale, scale_power_for_brightness(), and fl::CLEDController::visitControllers().

Here is the call graph for this function: