Arduino function to fade an RGB from one color to the next

Question

For my Arduino project I have a Neopixel RGB Strip with 72 LED's.

I can successfully change the colour of any of the LED's (at the moment I'm only setting the first one 0 for testing purposes) so I know my wiring isn't the problem here, it's my coding.

What I would like to do is be able to select a color and then another color and have the first color fade to the next color and so forth (much like the LIFX bulbs behave when using the iPhone application).

This is what I have at the moment:

I am logging output of all the variables to give you an indication of what's going on. I'm not 100% sure on where I'm going wrong or whether there's a much easier way to do what I'm after (I'm open to suggestions).

The function takes a parameter called command, which is a string separated by commas:

e.g. 255, 0, 0 (RED) or 0, 255, 0 (GREEN).

/*******************************************************************************
 * Function Name  : tinkerSetColour
 * Description    : Sets the strip with the appropriate colour
 * Input          : Pin and value
 * Output         : None.
 * Return         : 1 on success and a negative number on failure
 *******************************************************************************/
int Rstart = 0, Gstart = 0, Bstart = 0;
int Rnew = 0, Gnew = 0, Bnew = 0;

int tinkerSetColour(String command)
{
    sprintf(rgbString, "Rstart %i, Gstart %i, Bstart %i", Rstart, Gstart, Bstart);
    Spark.publish("rgb", rgbString);

    sprintf(rgbString, "Rnew %i, Gnew %i, Bnew %i", Rnew, Gnew, Bnew);
    Spark.publish("rgb", rgbString);

    // Clear strip.
    strip.show();

    int commaIndex = command.indexOf(',');
    int secondCommaIndex = command.indexOf(',', commaIndex+1);
    int lastCommaIndex = command.lastIndexOf(',');

    int red = command.substring(0, commaIndex).toInt();
    int grn = command.substring(commaIndex+1, secondCommaIndex).toInt();
    int blu = command.substring(lastCommaIndex+1).toInt();

    int Rend = red, Gend = grn, Bend = blu;

    sprintf(rgbString, "Rend %i, Gend %i, Bend %i", Rend, Gend, Bend);
    Spark.publish("rgb", rgbString);

    // Larger values of 'n' will give a smoother/slower transition.
    int n = 200;
    for (int i = 0; i < n; i++)
    {
        Rnew = Rstart + (Rend - Rstart) * i / n;
        Gnew = Gstart + (Gend - Gstart) * i / n;
        Bnew = Bstart + (Bend - Bstart) * i / n;

        // Set pixel color here.
        strip.setPixelColor(0, strip.Color(Rnew, Gnew, Bnew));
    }

    sprintf(rgbString, "Rnew %i, Gnew %i, Bnew %i", Rnew, Gnew, Bnew);
    Spark.publish("rgb", rgbString);

    Rstart = red, Gstart = grn, Bstart = blu;

    sprintf(rgbString, "Rstart %i, Gstart %i, Bstart %i", Rstart, Gstart, Bstart);
    Spark.publish("rgb", rgbString);

    return 1;
}

The problem is the colors are not fading between themselves.

Apologies if any of this is confusing. I can provide more information if necessary.

Here's the output selecting RED to begin with:

Rstart 0, Gstart 0, Bstart 0
Rnew 0, Gnew 0, Bnew 0
Rend 255, Gend 0, Bend 0
Rnew 253, Gnew 0, Bnew 0

Here's the output selecting GREEN directly afterwards:

Rstart 255, Gstart 0, Bstart 0
Rnew 253, Gnew 0, Bnew 0
Rend 0, Gend 255, Bend 0
Rnew 2, Gnew 253, Bnew 0

And then the output selecting BLUE after that:

Rstart 0, Gstart 255, Bstart 0
Rnew 2, Gnew 253, Bnew 0
Rend 0, Gend 23, Bend 255
Rnew 0, Gnew 25, Bnew 253

Answer 1

I think your code is not so bad, you just need delays. Because your forloop will be too quick for you to notice the fading.

From a project I'm working on, here is a c++/pseudocode example for fading a led between to rgb colors.

It can be modified to work with your library pretty easily. The Serial.print() are for a debug purpose and can be removed once it works. Notice at the end of each loop iteration the waitMS(). you can also replace it with the Arduino delay() function.

void fade(uint16_t duration, Color startColor, Color endColor) {

    int16_t redDiff = endColor.getR() - startColor.getR();
    int16_t greenDiff = endColor.getG() - startColor.getG();
    int16_t blueDiff = endColor.getB() - startColor.getB();

    int16_t delay = 20;
    int16_t steps = duration / delay;

    int16_t redValue, greenValue, blueValue;

    for (int16_t i = 0 ; i < steps - 1 ; ++i) {
        redValue = (int16_t)startColor.getR() + (redDiff * i / steps);
        greenValue = (int16_t)startColor.getG() + (greenDiff * i / steps);
        blueValue = (int16_t)startColor.getB() + (blueDiff * i / steps);

        Serial.print(redValue);
        Serial.print("\t");
        Serial.print(greenValue);
        Serial.print("\t");
        Serial.print(blueValue);
        Serial.println("\t");

        led.shine(redValue, greenValue, blueValue);
        waitMs(delay);
    }

    led.shine(endColor);
}

Hope this helps :)

EDIT:

Here is links to the code of Color and Led:

• Led Class
• Color Class

Answer 2

I've been working on the same problem for a couple days. I'm fairly new to arduino and coding so my code might be a bit simple, but for right now this seems to work.

I'm using the FastLED library.

#include "FastLED.h"

#define NUM_LEDS 15

#define DATA_PIN 6

CRGB leds[NUM_LEDS];

 int fade = 2; //minutes

   byte cred; //current red
   byte cgreen;
   byte cblue;
   byte targetred; //red after fade
   byte targetgreen;
   byte targetblue;
   byte oldred; //red before fade
   byte oldgreen;
   byte oldblue;
   byte deltared; //difference before and after fade
   byte deltagreen;
   byte deltablue;

unsigned long start;
unsigned long current;
unsigned long whole; 


void setup() { 
      FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
  cred = 0; cblue = 0; cgreen = 0;
  oldred = 0; oldblue = 0; oldgreen = 0;
  update();
  start = millis();

}

void loop() {
  targetred = 20;
  targetgreen = 220;
  targetblue = 130;
  deltared = targetred - oldred; deltagreen = targetgreen - oldgreen; deltablue = targetblue - oldblue;
  whole = fade * 60000 + start; //fade time in milliseconds

  if (cred <= targetred && millis() <= whole){
  current = millis();
  cred = current * deltared / whole;
  cred = cred + oldred;}

if (cgreen <= targetgreen && millis() <= whole){
  current = millis();
  cgreen = current * deltagreen / whole;
  cgreen = cgreen + oldgreen;}

  if (cblue <= targetblue && millis() <= whole){
  current = millis();
  cblue = current * deltablue / whole;
  cblue = cblue + oldblue;}

  update();

}

void update(){
 for (int i = 0; i <= NUM_LEDS; i++){
  leds[i] = CRGB (cred, cgreen, cblue);
  FastLED.show();
  }};

This version doesn't actually fade to another colour afterwards, but you would just assign oldred = cred etc, then update your targetcolours. another thing is that this code is tuned to fade up due to the if cred <= target red. I originally was using != but sometimes ccolour would shoot past ctarget and keep going. I need to figure out how to set better tolerances. I am trying to avoid using delay so it will be easier later to receive outside input without lag.

Anyway, it's good to look at the same problem from different approaches, and this is another. Good luck with your fades!