Help about random fading spots

[ghost]

I kindly ask a hint about how you would approach this request.
Given a WS2812 LED strip with N pixel, I need to turn on and off a single random pixel (with a #defined fade in/out time) to a random hue color (S and L are #defined too). Not a single pixel at time, but here and there can be different pixels that fade independently.

My approach is:

• another way to describe the above behavior, is that every pixel fades in/out with a random time
• hence, I can setup N animations that will start at random time. It would be nice to use the RestartAnimation() method, but I'm not sure if I can delay it with a random time. I mean, I cannot use delay() inside the handler, can I?
• I can write the animation handler in order to fade in between progress 0.0 and 0.5 and fade out between 0.5 and 1.0

I don't think I can avoid N animations (one per LED) since I need different states for each one in order to have N independent animations.

Is my guess right? Is there a more recommended approach?

[Makuna]

You really should avoid delay() in all modern Arduino projects except for simple tests. It blocks other code from running far too often. Either use a task library (esp is RTOS and supports tasks natively) or use a micros() polling pattern. If you look in the NeoPixelAnimator.cpp for NeoPixelAnimator::UpdateAnimations(), you can see that it uses this pattern.

You could use a single channel to do it, tracking all the state BUT this is what the animation manager already does so its not really going to save you anything.

Using an animation channel per "twinkle" (this sort of animation you describe) is the normal approach. Generally, you would write a manager that tracks a set of available channels that it can use and their lifetime (is a single twinkle still animating or done so it can be reused). The manager would decide on when to create a twinkle, select an available channel from its set, and start the animation. The manager would be called in setup like "twinkleMan.update()", and internally use the millis() progress pattern instead of delay().

The twinkle animation callback could be written either to handle both fade in a fade out, or you could have two, one for fade in, that when complete uses the same channel to start another animation for fade out; where when the fade out completes, it releases the channel to be reused by the manager. This would give you the flexibility to have different timing to fade in and fade out.

[Makuna]

Further there is no reason the animation couldn't be tri-state (3 separate callbacks), fade in, fade out, delay. The delay would just check for complete before releasing the channel for the manager to reuse.

[ghost]

Thanks for you hints! I'm not sure I understood them completely. I tried to write the following code. It works, but I cannot change the duration of each phase since the RestartAnimation() function does not provide a new duration argument:

void Segment::Twinkle()
{
    for (int i = 1; i < _length + 1; i++) // _length is the size of my strip
    {
        _twinkleAnimationState[i].state = TwinkleStates::Off;

        int duration = random(TWINKLE_OFF_MIN[_index], TWINKLE_OFF_MAX[_index]); // these are constants to define the range of the variables
        _animation.StartAnimation(i, duration, [this](const AnimationParam &param)
        {
            // handle the 4 states: off, fadein, on, fadeout
            switch (this->_twinkleAnimationState[param.index].state)
            {
            case TwinkleStates::Off: {
                if (param.state == AnimationState_Completed)
                {
                    float h = randomDouble(TWINKLE_H_MIN[_index], TWINKLE_H_MAX[_index]);
                    float s = randomDouble(TWINKLE_S_MIN[_index], TWINKLE_S_MAX[_index]);
                    float l = randomDouble(TWINKLE_L_MIN[_index], TWINKLE_L_MAX[_index]);        
                    HslColor color(h, s, l);

                    _twinkleAnimationState[param.index].StartingColor = _twinkleAnimationState[param.index].CurrentColor;
                    _twinkleAnimationState[param.index].EndingColor = color;

                    this->_twinkleAnimationState[param.index].state = TwinkleStates::FadeIn;
                    int duration = random(TWINKLE_FADEIN_MIN[_index], TWINKLE_FADEIN_MAX[_index]);
                    this->_animation.RestartAnimation(param.index); // <--- how to use the new duration?
                }
                break; }
            
            case TwinkleStates::FadeIn: {
                float progress = NeoEase::ExponentialIn(param.progress);
                HslColor updatedColor = HslColor::LinearBlend<NeoHueBlendShortestDistance>(_twinkleAnimationState[param.index].StartingColor, _twinkleAnimationState[param.index].EndingColor, progress);
                this->_twinkleAnimationState[param.index].CurrentColor = updatedColor;
                _strip->SetPixelColor(param.index + _offset, updatedColor); 

                if (param.state == AnimationState_Completed)
                {
                    this->_twinkleAnimationState[param.index].state = TwinkleStates::On;
                    int duration = random(TWINKLE_ON_MIN[_index], TWINKLE_ON_MAX[_index]);
                    this->_animation.RestartAnimation(param.index);
                }
                break; }

            case TwinkleStates::On: {
                if (param.state == AnimationState_Completed)
                {
                    _twinkleAnimationState[param.index].StartingColor = _twinkleAnimationState[param.index].CurrentColor;
                    _twinkleAnimationState[param.index].EndingColor = HslColor(_twinkleAnimationState[param.index].CurrentColor.H, _twinkleAnimationState[param.index].CurrentColor.S, 0.0);

                    this->_twinkleAnimationState[param.index].state = TwinkleStates::FadeOut;
                    int duration = random(TWINKLE_FADEOUT_MIN[_index], TWINKLE_FADEOUT_MAX[_index]);
                    this->_animation.RestartAnimation(param.index);
                }
                break; }

            case TwinkleStates::FadeOut: {
                float progress = NeoEase::ExponentialIn(param.progress);
                HslColor updatedColor = HslColor::LinearBlend<NeoHueBlendShortestDistance>(_twinkleAnimationState[param.index].StartingColor, _twinkleAnimationState[param.index].EndingColor, progress);            
                this->_twinkleAnimationState[param.index].CurrentColor = updatedColor;
                _strip->SetPixelColor(param.index + _offset, updatedColor); 

                if (param.state == AnimationState_Completed)
                {
                    this->_twinkleAnimationState[param.index].state = TwinkleStates::Off;
                    int duration = random(TWINKLE_OFF_MIN[_index], TWINKLE_OFF_MAX[_index]);
                    this->_animation.RestartAnimation(param.index);
                }
                break; }
            }
        });
    }
}

Is there a way to change the duration inside the callback?
Otherwise I'm thinking to check if the animation has finished outside the callback (i.e. from the main loop) and start manually the new animation updating its state.

I can do that, but I wonder if I can do this without using an external FSM.

[ghost]

I think I solved adding:

this->_animation.ChangeAnimationDuration(param.index, duration);

before restarting the animation.

[Makuna]

You can also just call start animation if you weren't using lambdas. But your approach is good.