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 574 of file FastLED.cpp.hpp.

                                                                                   {
#if FL_COLOR_PIPELINE_SHARED
    if (apply_limiter && mPPowerFunc && fl::activeFramePowerDispatch()) {
        bool managed = false;
        for (CLEDController* p = CLEDController::head(); p; p = p->next()) {
            if (p->getEnabled() && fl::channelColorPipeline(*p)) {
                managed = true;
                break;
            }
        }
        if (managed) {
            const fl::FramePowerPlan plan =
                fl::activeFramePowerDispatch()->calculate(mScale, mNPowerData);
            if (plan.modeled_mW == 0xFFFFFFFFu) return plan.modeled_mW;
            const fl::u32 mcu_mW = plan.mcu_mW;
            return plan.modeled_mW > mcu_mW ? plan.modeled_mW - mcu_mW : 0;
        }
    }
#endif
    fl::u32 fixed_power_mW = 0;
    fl::u32 controllable_power_mW = 0;
    fl::u32 dither_reserve_power_mW = 0;
 
    // Sum unscaled power from all LED controllers using visitor pattern.
    // The dark-current baseline is kept apart from the part brightness scales,
    // because it is drawn at every brightness including zero (#4156 R4).
    const fl::u32 dark_mW_per_led = get_power_model().dark_mW;
    CLEDController::visitControllers([&](const CLEDController* controller, fl::span<const CRGB> leds) {
        if (!leds.empty()) {
            // The controller's own estimate: its RGBW setting, so an RGBW strip
            // is charged for the diode it actually lights, and for a bound
            // colour profile the solved drives rather than the source (#4344).
            const fl::u32 unscaled_mW = controller_unscaled_power_mW(*controller);
            const fl::u32 dark_mW = dark_mW_per_led * static_cast<fl::u32>(leds.size());
            fixed_power_mW += dark_mW;
            controllable_power_mW += unscaled_mW > dark_mW ? unscaled_mW - dark_mW : 0;
            // What dithering can add on top, at any non-zero brightness (#4342).
            // Not on TINY, where the bound costs more flash than the tier has
            // to spare (#4478); controller_dither_reserve_mW is 0 there.
#if !FL_PLATFORM_HAS_TINY_MEMORY
            dither_reserve_power_mW += controller_dither_reserve_mW(*controller);
#endif
        }
    });
 
    // 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 only the emitter share by the configured power-brightness response
    // and add the baseline back, so the estimate matches what the limiter now
    // budgets against.
    // Note: MCU power consumption is NOT included - caller should add platform-specific MCU power if needed
    // The dither reserve only at a non-zero brightness: nothing dithers at 0,
    // the same as the limiter, whose answer of 0 needs no reserve either.
    if (effective_brightness != 0) {
        fixed_power_mW += dither_reserve_power_mW;
    }
    return fixed_power_mW +
           scale_power_for_brightness(controllable_power_mW, effective_brightness);
}

References controller, controller_dither_reserve_mW(), controller_unscaled_power_mW(), PowerModelRGB::dark_mW, fixed_power_mW(), FL_NO_EXCEPT, get_power_model(), fl::CLEDController::head(), leds(), fl::FramePowerPlan::mcu_mW, mNPowerData, fl::FramePowerPlan::modeled_mW, mPPowerFunc, mScale, scale_power_for_brightness(), and fl::CLEDController::visitControllers().

Here is the call graph for this function: