calculate_unscaled_power_mW() [3/3]

fl::u32 calculate_unscaled_power_mW	(	fl::span< const CRGB >	leds,
		const fl::Rgbw &	rgbw )

Same, for a strip driven through the RGBW conversion.

The overloads above read the source CRGB triple, which is what the sketch wrote – not what the strip is driven with. A controller in RGBW mode converts every pixel with rgb_2_rgbw before latching, and the resulting four drives are neither bounded by nor proportional to the source triple. Measured on the shipped default PowerModelRGBW at full white, in units of the sum below: source-triple 249 against a true 348 under kRGBWMaxBrightness, 266 under kRGBWBoostedWhite, 99 under kRGBWExactColors. The first two are the budget being under-spent against; the third is a strip dimmed for no reason.

This runs the same conversion the encoder will and charges all four emitters. It needs white_mW, so it falls back to the three-emitter figure – and says so once – when the caller declared only an RGB model.

Parameters

leds	span of LED data to check
rgbw	the controller's RGBW setting; an inactive one delegates to the three-emitter overload

Definition at line 317 of file power_mgt.cpp.hpp.

                                                                                            {
    const fl::u8 white_mW = gWhiteEmitterPower().mW;
    // `!rgbw.active()` is a fast path, not a different answer: the only
    // inactive mode is `kRGBWInvalid`, which `rgb_2_rgbw` dispatches to
    // null-white -- RGB passed through with w = 0 -- so the loop below would
    // return the same total. Removing the test changes nothing observable
    // and costs one conversion per pixel on every plain RGB controller in
    // the sketch, which the estimator walks once per frame.
    //
    // The `white_mW == 0` half *is* behavioural: with no declared white
    // there is nothing to charge the fourth diode at.
    if (!rgbw.active() || white_mW == 0) {
        if (rgbw.active()) {
            FL_WARN_ONCE("power: controller is in RGBW mode but the power model "
                         "declares no white emitter, so the budget covers three "
                         "of its four diodes. Call "
                         "FastLED.setPowerModel(PowerModelRGBW(...)) to fix it.");
        }
        return calculate_unscaled_power_mW(leds);
    }
 
    fl::u32 red32 = 0, green32 = 0, blue32 = 0, white32 = 0;
    for (fl::size i = 0; i < leds.size(); i++) {
        fl::u8 r = 0, g = 0, b = 0, w = 0;
        fl::rgb_2_rgbw(rgbw, leds[i].r, leds[i].g, leds[i].b, 255, 255, 255,
                       &r, &g, &b, &w);
        red32   += map_power_value(r);
        green32 += map_power_value(g);
        blue32  += map_power_value(b);
        white32 += map_power_value(w);
    }
 
    red32   *= gPowerModel().red_mW;
    green32 *= gPowerModel().green_mW;
    blue32  *= gPowerModel().blue_mW;
    white32 *= white_mW;
 
    red32   >>= 8;
    green32 >>= 8;
    blue32  >>= 8;
    white32 >>= 8;
 
    return red32 + green32 + blue32 + white32 +
           (gPowerModel().dark_mW * leds.size());
}

References PowerModelRGB::blue_mW, calculate_unscaled_power_mW(), PowerModelRGB::dark_mW, FL_NO_EXCEPT, FL_WARN_ONCE, gPowerModel(), PowerModelRGB::green_mW, gWhiteEmitterPower(), leds, map_power_value(), WhiteEmitterPower::mW, PowerModelRGB::red_mW, fl::rgb_2_rgbw(), and rgbw.

Here is the call graph for this function: