My Question for the Community is two-fold: 1.

Archive FastLED Archive
1

My Question for the Community is two-fold:

  1. Are there any comprehensive Tweening Libs already available? I’m currently writing my own code to be able to animate a bar (e.g. 6 LED in a row) down a strip and use easing like Bounce and Elastic to make them stop. But the more I code, the more I get the feeling: I cant be the first one to write this code. Am I missing a lib from the cummunity?

  2. fastLED does support multiple Strips. Could this also be supported wireless? I would love to have multiple modules in a room and send an animation down the module and at the end it should continue on another like it is chained. I was thinking about an ESP or plain RF433Mhz and trigger the Modules via RF to continue the placback (either by a Master Logic or by a mesh logic). Yet, easing needed to be calculated first and then transmitted to the modules. Does someone know of a project where this was already done and I can learn from?

Thank you!
Indy

2

@Indyaner_Jones to answer your first question depends exactly what you wanna do you will find a lot of people dealing with that. I do boucing of pictures for instance. on your second point it depends if you want to go for a all in board. I use esp8266 and esp32 for my projects with wi-fi capabilities. I can refresh 6000 leds with a 30fps frame rate via wifi.
here is a link to my project and links to different parts of the code

3

Maybe look at the bpm or juggle function in the DemoReel100.ino example included in the library. I’ve adapted it to multiple strands and am about to playing with it to do exactly what you are. (I’m actually here because I thought the same thing you did: “Somebody has already done this” and they have. The guy that coded the fire example in the library, Mark Kriegsman, did a great bounce effect in this video: https://www.youtube.com/watch?v=knWiGsmgycY but I haven’t been able to find the code. I’d like to get the code for all the effects he does here.

4

For Easing I currently use these Functions:

Here is a very simple implementation with a red dot Bounce.easeOut of the End of the Strip
(demo gif: https://media.giphy.com/media/2tQq8f1bCwwTxbKYsQ/giphy.gif)

#include “Arduino.h”
#include “FastLED.h”

#include <BounceEase.h>
#include <QuarticEase.h>
#include <QuinticEase.h>
#include <BackEase.h>
#include <ElasticEase.h>

#define PIN_DATA 9
#define COLOR_ORDER GRB
#define CHIPSET WS2812
#define NUM_LEDS 64

// Easing
double runner = 0;
double runnerSpeed = 0.01;
int index = 0;

// Easing Functions
QuarticEase easeQuartic;
QuinticEase easeQuintic;
BounceEase easeBounce;
BackEase easeBack;
ElasticEase easeElastic;

struct CRGB leds[NUM_LEDS];

void setup() {

set_max_power_in_volts_and_milliamps(5, 450);// FastLED Power management set at 5V, 500mA.

FastLED.setBrightness(40); //Low value while testing

FastLED.addLeds<CHIPSET, PIN_DATA, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );

FastLED.clear();

//This is the one we are currently processing in the loop
easeBounce.setDuration(1);
easeBounce.setTotalChangeInPosition(NUM_LEDS-1);

//this could also be used in the loop
easeQuartic.setDuration(1);
easeQuartic.setTotalChangeInPosition(NUM_LEDS-1);

easeQuintic.setDuration(1);
easeQuintic.setTotalChangeInPosition(NUM_LEDS-1);

//I also add these to this demo code, as they are a bit tricky to use because of the overshot value
easeBack.setDuration(1);
easeBack.setOvershoot(2);
easeBack.setTotalChangeInPosition(NUM_LEDS-1);

easeElastic.setDuration(1);
easeElastic.setPeriod(0);
easeElastic.setAmplitude(0);
easeElastic.setTotalChangeInPosition(NUM_LEDS-1);

}

void loop() {

EVERY_N_MILLISECONDS(20) {
processEase();
FastLED.show();
}

}

void processEase(){

//Increase Runner 0.00 to 1.00 incrementing at 0.01 - 0.08 at best
runner += runnerSpeed;
//The calculated LED for the current Step in the ease
index = easeBounce.easeOut(runner);
//Reset on reach
if(runner>1) runner = 0;

//FastLED write
leds[index] = CRGB::Red;
//This will give the nice tail.
fadeToBlackBy(leds, NUM_LEDS, 80);

}