colourPalette_code.ino File Reference

Functions
void	FillLEDsFromPaletteColors (uint8_t colorIndex)
void	FillStripesFromPaletteColors (uint8_t colorIndex)
void	FillPatternStripesFromPaletteColors (uint8_t colorIndex, uint8_t var)
void	PaletteSetup ()
void	ChangePalettePeriodically ()
void	ChangePalettePeriodically2 ()
void	ChangePalettePeriodically3 ()
void	ChangeStripesPeriodically ()
void	ChangePaletteEveryTime ()
void	SetupTotallyRandomPalette ()
void	SetupBlackAndWhiteStripedPalette ()
void	SetupPurpleAndGreenPalette ()
void	SetupVariablePalette (CRGB a, CRGB b, CRGB c, CRGB d)
void	SetupVariableStripes (CRGB a, CRGB b, CRGB c, CRGB d)
void	SetupVariablePalette3 (CRGB a, CRGB b, CRGB c)
void	SetupVariablePalette5 (CRGB a, CRGB b, CRGB c, CRGB d, CRGB e)
void	SetupVariablePalette6 (CRGB a, CRGB b, CRGB c, CRGB d, CRGB e, CRGB f)
void	SetupVariablePalette7 (CRGB a, CRGB b, CRGB c, CRGB d, CRGB e, CRGB f, CRGB g)
void	SetupRandomVariablePalette (CRGB a, CRGB b, CRGB c, CRGB d)
void	SetupRandomVariablePalette2 (CRGB a, CRGB b, CRGB c, CRGB d)
void	add_glitter ()
void	funColourJam ()
	Implements the "Colour Jam" pattern.

Variables
const TProgmemPalette16 myRedWhiteBluePalette_p	PROGMEM

Function Documentation

add_glitter()

void add_glitter

(

)

{
  int chance_of_glitter =  10; // percent of the time that we add glitter
  int number_of_glitters = 5; // number of glitter sparkles to add
 
  int r = random8(100);
  if ( r < chance_of_glitter ) {
    for ( int j = 0; j < number_of_glitters; j++) {
      int pos = random16( NUM_LEDS);
      leds[pos] = CRGB::White; // very bright glitter
    }
  }
}

References leds, and NUM_LEDS.

ChangePaletteEveryTime()

void ChangePaletteEveryTime

(

)

{
  paletteVar++;
  ////Serial.println(paletteVar);
  if ( paletteVar == 1)   {
    SetupVariablePalette(CRGB::Red, CRGB::Gray, CRGB::Blue, CRGB::Black);
  }
  if ( paletteVar == 2)  {
    SetupRandomVariablePalette(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
  }
  if ( paletteVar == 3)  {
    SetupVariablePalette(CRGB::Green, CRGB::Gray, CRGB::Pink, CRGB::Black);
  }
  if ( paletteVar == 4)  {
    SetupRandomVariablePalette(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
  }
  if ( paletteVar == 5)  {
    SetupVariablePalette(CRGB::Orange, CRGB::Gray, CRGB::Cyan, CRGB::Black);
  }
  if ( paletteVar == 6)  {
    SetupRandomVariablePalette(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
  }
  if ( paletteVar == 7)  {
    SetupVariablePalette(CRGB::Magenta, CRGB::Gray, CRGB::Yellow, CRGB::Black);
  }
  if ( paletteVar == 8)  {
    SetupRandomVariablePalette(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
  }
  if ( paletteVar == 9)  {
    SetupVariablePalette(CRGB::Blue, CRGB::Gray, CRGB::Green, CRGB::Black);
  }
  if ( paletteVar == 10)  {
    SetupRandomVariablePalette(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
  }
  if (paletteVar == 11) {
    paletteVar = 0;
  }
 
 
}

References paletteVar, SetupRandomVariablePalette(), and SetupVariablePalette().

Here is the call graph for this function:

ChangePalettePeriodically()

void ChangePalettePeriodically

(

)

{
  uint8_t secondHand = (millis() / 1000) % 60;
  static uint8_t lastSecond = 99;
 
  if ( lastSecond != secondHand) {
    lastSecond = secondHand;
    //if( secondHand == 1)   { SetupVariablePalette(CRGB::Red, CRGB::Gray, CRGB::Blue, CRGB::Black); }
    if ( secondHand == 15)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 20)  { SetupVariablePalette(CRGB::Green, CRGB::Gray, CRGB::Pink, CRGB::Black); }
    if ( secondHand == 25)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 30)  { SetupVariablePalette(CRGB::Orange, CRGB::Gray, CRGB::Cyan, CRGB::Black); }
    if ( secondHand == 35)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 40)  { SetupVariablePalette(CRGB::Magenta, CRGB::Gray, CRGB::Yellow, CRGB::Black); }
    if ( secondHand == 45)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 50)  { SetupVariablePalette(CRGB::Blue, CRGB::Gray, CRGB::Green, CRGB::Black); }
    if ( secondHand == 55)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
  }
}

References SetupRandomVariablePalette2().

Here is the call graph for this function:

ChangePalettePeriodically2()

void ChangePalettePeriodically2

(

)

{
  uint8_t secondHand = (millis() / 1000) % 60;
  static uint8_t lastSecond = 99;
 
  if ( lastSecond != secondHand) {
    lastSecond = secondHand;
    //if( secondHand == 1)   { SetupVariablePalette(CRGB::Red, CRGB::Gray, CRGB::Blue, CRGB::Black); }
    if ( secondHand == 15)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 20)  { SetupVariablePalette(CRGB::Green, CRGB::Gray, CRGB::Pink, CRGB::Black); }
    if ( secondHand == 25)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 30)  { SetupVariablePalette(CRGB::Orange, CRGB::Gray, CRGB::Cyan, CRGB::Black); }
    if ( secondHand == 35)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 40)  { SetupVariablePalette(CRGB::Magenta, CRGB::Gray, CRGB::Yellow, CRGB::Black); }
    if ( secondHand == 45)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
    //if( secondHand == 50)  { SetupVariablePalette(CRGB::Blue, CRGB::Gray, CRGB::Green, CRGB::Black); }
    if ( secondHand == 55)  {
      SetupRandomVariablePalette2(CRGB::Black, CRGB::Gray, CRGB::Black, CRGB::Gray);
    }
  }
}

References SetupRandomVariablePalette2().

Here is the call graph for this function:

ChangePalettePeriodically3()

void ChangePalettePeriodically3

(

)

{
  uint8_t secondHand = (millis() / 1000) % 120; //last number is number of seconds the whole thing lasts!
  static uint8_t lastSecond = 121;
 
  if ( lastSecond != secondHand) {
    lastSecond = secondHand;
    if ( secondHand == 1)   {
      SetupVariablePalette3(CRGB::Red, CRGB::Black, CRGB::Blue);
    }
    if ( secondHand == 10)  {
      SetupVariablePalette3(CRGB::Magenta, CRGB::Black, CRGB::Green);
    }
    if ( secondHand == 20)  {
      SetupVariablePalette3(CRGB::Cyan, CRGB::Black, CRGB::Yellow);
    }
    if ( secondHand == 30)  {
      SetupVariablePalette3(CRGB::Red, CRGB::Black, CRGB::Green);
    }
    if ( secondHand == 40)  {
      SetupVariablePalette3(CRGB::Cyan, CRGB::Black, CRGB::Magenta);
    }
    if ( secondHand == 50)  {
      SetupVariablePalette3(CRGB::Black, CRGB::Red, CRGB::Cyan);
    }
 
    if ( secondHand == 60)  {
      SetupVariablePalette(CRGB::Red, CRGB::Black, CRGB::Blue, CRGB::Black);
    }
    if ( secondHand == 70)  {
      SetupVariablePalette(CRGB::Cyan, CRGB::Black, CRGB::Yellow, CRGB::Black);
    }
    if ( secondHand == 80)  {
      SetupVariablePalette(CRGB::Red, CRGB::Black, CRGB::Green, CRGB::Black);
    }
    if ( secondHand == 90)  {
      SetupVariablePalette(CRGB::Cyan, CRGB::Black, CRGB::Magenta, CRGB::Black);
    }
    if ( secondHand == 100) {
      SetupVariablePalette(CRGB::Green, CRGB::Black, CRGB::Blue, CRGB::Black);
    }
 
    if ( secondHand == 60)  {
      SetupVariablePalette5(CRGB::BlueViolet, CRGB::Black, CRGB::Amethyst, CRGB::Black, CRGB::Coral);
    }
    if ( secondHand == 70)  {
      SetupVariablePalette5(CRGB::Chocolate, CRGB::Black, CRGB::DarkCyan, CRGB::Black, CRGB::DarkGoldenrod);
    }
    if ( secondHand == 80)  {
      SetupVariablePalette5(CRGB::DarkOliveGreen, CRGB::DodgerBlue, CRGB::Green, CRGB::Black, CRGB::DarkOrchid);
    }
    if ( secondHand == 90)  {
      SetupVariablePalette5(CRGB::Lavender, CRGB::Black, CRGB::IndianRed, CRGB::Black, CRGB::FloralWhite);
    }
    if ( secondHand == 100) {
      SetupVariablePalette5(CRGB::MediumTurquoise, CRGB::Black, CRGB::Blue, CRGB::Black, CRGB::Lime);
    }
    if ( secondHand == 110) {
      //toggle between lines and zigzag pattern (using same palettes above!)
      if (lines == false) {
        lines = true;
      }
      else {
        lines = false;
      }
      setting = 2;
 
    }
 
 
 
  }
}

References lines, setting, SetupVariablePalette(), SetupVariablePalette3(), and SetupVariablePalette5().

Referenced by funColourJam().

Here is the call graph for this function:

Here is the caller graph for this function:

ChangeStripesPeriodically()

void ChangeStripesPeriodically

(

)

{
  uint8_t secondHand = (millis() / 1000) % 60; //last number is number of seconds the whole thing lasts!
  static uint8_t lastSecond = 99;
 
  if ( lastSecond != secondHand) {
    lastSecond = secondHand;
    if ( secondHand == 1 )  {
      SetupVariablePalette(CRGB::Red, CRGB::Black, CRGB::Yellow, CRGB::Black);
    }
    if ( secondHand == 10)  {
      SetupVariablePalette(CRGB::Red, CRGB::Black, CRGB::Blue, CRGB::Black);
    }
    if ( secondHand == 20)  {
      SetupVariablePalette(CRGB::Cyan, CRGB::Black, CRGB::Yellow, CRGB::Black);
    }
    if ( secondHand == 30)  {
      SetupVariablePalette(CRGB::Red, CRGB::Black, CRGB::Green, CRGB::Black);
    }
    if ( secondHand == 40)  {
      SetupVariablePalette(CRGB::Cyan, CRGB::Black, CRGB::Magenta, CRGB::Black);
    }
    if ( secondHand == 50)  {
      SetupVariablePalette(CRGB::Green, CRGB::Black, CRGB::Blue, CRGB::Black);
    }
    if ( secondHand == 59)  {
      setting++;
      if (setting > 3) {
        setting = 1;
      }
    }
 
 
  }
}

References setting, and SetupVariablePalette().

Referenced by funColourJam().

Here is the call graph for this function:

Here is the caller graph for this function:

FillLEDsFromPaletteColors()

void FillLEDsFromPaletteColors

(

uint8_t

colorIndex

)

{
  uint8_t brightness = 255;
 
  for ( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
    colorIndex += 3; //this is something to change the pattern nicely!
  }
 
}

References currentBlending, currentPalette, leds, and NUM_LEDS.

Referenced by funColourJam().

Here is the caller graph for this function:

FillPatternStripesFromPaletteColors()

void FillPatternStripesFromPaletteColors	(	uint8_t	colorIndex,
		uint8_t	var )

{
  uint8_t brightness = 255;
 
  for ( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
    colorIndex = colorIndex + var; //change this to change pattern nicely!!
  }
 
}

References currentBlending, currentPalette, leds, and NUM_LEDS.

Referenced by funColourJam().

Here is the caller graph for this function:

FillStripesFromPaletteColors()

void FillStripesFromPaletteColors

(

uint8_t

colorIndex

)

{
  uint8_t brightness = 255;
 
  for ( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
    colorIndex = colorIndex + colorIndex % 4; //change this to change pattern nicely!!
  }
 
}

References currentBlending, currentPalette, leds, and NUM_LEDS.

Referenced by funColourJam().

Here is the caller graph for this function:

funColourJam()

void funColourJam

(

)

Implements the "Colour Jam" pattern.

This function generates a dynamic color pattern based on the current setting. It uses palettes and motion to create a visually appealing effect.

Parameters

None

Returns

None

Precondition

FastLED library is initialized and ready for use.

Postcondition

Updates the LED strip with a new color pattern.

Note

This function is called repeatedly to update the pattern.

Uses global variables such as setting, lines, upDown, motionSpeed, maxStartIndex, and minStartIndex.

Calls other functions such as ChangePalettePeriodically3(), FillLEDsFromPaletteColors(), ChangeStripesPeriodically(), and FillStripesFromPaletteColors().

{
  if (setting == 1)
  {
 
    if (lines == false)
    { 
      ChangePalettePeriodically3();
      static uint8_t startIndex = 0;
      if (upDown == true)
      {
        startIndex = startIndex + motionSpeed;
        FillLEDsFromPaletteColors(startIndex);
        if (startIndex == maxStartIndex)
        {
          upDown = false;
        }
      }
      else
      {
        startIndex = startIndex - motionSpeed;
        FillLEDsFromPaletteColors(startIndex);
        if (startIndex == minStartIndex)
        {
          upDown = true;
        }
      }
 
      // add_glitter();
 
      FastLED.show();
      // FastLED.delay(1); // for 160mhz APA102 px<72 only
    }
    else
    {
      ChangePalettePeriodically3();
      static uint8_t startIndex = 0;
      startIndex = startIndex + motionSpeed; /* motion speed */
      FillLEDsFromPaletteColors(startIndex);
      if (startIndex == maxStartIndex)
      {
        startIndex = 0;
      }
      // add_glitter();
      FastLED.show();
      // FastLED.delay(1); // for 160mhz APA102 px<72 only
    } 
  } 
 
  else if (setting == 2)
  {
    ChangeStripesPeriodically();
    static uint8_t stripeIndex = 0;
    stripeIndex = stripeIndex + 1;
    FillStripesFromPaletteColors(stripeIndex);
    ////Serial.println(startIndex);
    if (stripeIndex > 15)
    {
      stripeIndex = 0;
    }
    // add_glitter();
    FastLED.show();
    // FastLED.delay(1); // for 160mhz APA102 px<72 only
  } 
  else
  {
    ChangeStripesPeriodically();
    static uint8_t stripeIndex2 = 0;
    stripeIndex2 = stripeIndex2 + 1;
    FillPatternStripesFromPaletteColors(stripeIndex2, 4);
    if (stripeIndex2 > 15)
    {
      stripeIndex2 = 0;
    }
    // add_glitter();
    FastLED.show();
    // FastLED.delay(1); // for 160mhz APA102 px<72 only
    
  } 
}

References ChangePalettePeriodically3(), ChangeStripesPeriodically(), FillLEDsFromPaletteColors(), FillPatternStripesFromPaletteColors(), FillStripesFromPaletteColors(), lines, maxStartIndex, minStartIndex, motionSpeed, setting, and upDown.

Referenced by loop().

Here is the call graph for this function:

Here is the caller graph for this function:

PaletteSetup()

void PaletteSetup

(

)

                    {
  //currentPalette = RainbowColors_p;         currentBlending = BLEND; //not great needs modification for best pov look
  currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  //super awesome rainbows!
  //currentPalette = RainbowStripeColors_p;   currentBlending = BLEND; //also fantastic!
  //SetupPurpleAndGreenPalette();             currentBlending = BLEND; //good one
  //SetupTotallyRandomPalette();              currentBlending = BLEND; //too random
  //SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; //striking...
  //SetupBlackAndWhiteStripedPalette();       currentBlending = BLEND; //nice too...
  //currentPalette = CloudColors_p;           currentBlending = BLEND; //needs more contrast
  //currentPalette = PartyColors_p;           currentBlending = BLEND; //also needs contrast
  //currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  //yes yes yes it works
  //currentPalette = myRedWhiteBluePalette_p; currentBlending = BLEND; //nice
}

References currentBlending, and currentPalette.

SetupBlackAndWhiteStripedPalette()

void SetupBlackAndWhiteStripedPalette

(

)

{
  // 'black out' all 16 palette entries...
  fill_solid( currentPalette, 16, CRGB::Black);
  // and set every fourth one to white.
  currentPalette[0] = CRGB::White;
  currentPalette[4] = CRGB::White;
  currentPalette[8] = CRGB::White;
  currentPalette[12] = CRGB::White;
 
}

References currentPalette.

SetupPurpleAndGreenPalette()

void SetupPurpleAndGreenPalette

(

)

{
  CRGB purple = CHSV( HUE_PURPLE, 255, 255);
  CRGB green  = CHSV( HUE_GREEN, 255, 255);
  CRGB black  = CRGB::Black;
 
  currentPalette = CRGBPalette16(
                     green,  green,  black,  black,
                     purple, purple, black,  black,
                     green,  green,  black,  black,
                     purple, purple, black,  black );
}

References black, and currentPalette.

SetupRandomVariablePalette()

void SetupRandomVariablePalette	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d )

{
  CRGB rand1 = CHSV( random8(), 255, 255);
  CRGB rand2 = CHSV( random8(), 255, 255);
  CRGB rand3 = rand1 - rand2;
  //function to mix up order of a, b, c, d here? if 1 currentPalette is order no.1 if 2 currentPalette is order no.2
  currentPalette = CRGBPalette16(a, rand1, c, rand2, b, rand1, d, rand2, a, rand1, c, rand2, b, rand1, d, rand2);
}

References a, and currentPalette.

Referenced by ChangePaletteEveryTime().

Here is the caller graph for this function:

SetupRandomVariablePalette2()

void SetupRandomVariablePalette2	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d )

{
  // 'black out' all 16 palette entries...
  fill_solid( currentPalette, 16, CRGB::Black);
  // and set every fourth one to whatever.
  int r1 = random8(13);
  int r2 = random8(13);
  int r3 = random8(13);
  int r4 = random8(13);
  currentPalette[r1] = a;
  currentPalette[r2] = b;
  currentPalette[r3] = c;
  currentPalette[r4] = d;
}

References a, and currentPalette.

Referenced by ChangePalettePeriodically(), and ChangePalettePeriodically2().

Here is the caller graph for this function:

SetupTotallyRandomPalette()

void SetupTotallyRandomPalette

(

)

{
  for ( int i = 0; i < 16; i++) {
    currentPalette[i] = CHSV( random8(), 255, random8());
  }
}

References currentPalette.

SetupVariablePalette()

void SetupVariablePalette	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d )

{
 
  currentPalette = CRGBPalette16(a, b, c, d, a, b, c, d, a, b, c, d, a, b, c, d);
}

References a, and currentPalette.

Referenced by ChangePaletteEveryTime(), ChangePalettePeriodically3(), and ChangeStripesPeriodically().

Here is the caller graph for this function:

SetupVariablePalette3()

void SetupVariablePalette3	(	CRGB	a,
		CRGB	b,
		CRGB	c )

{
  currentPalette = CRGBPalette16(a, b, c, a, b, c, a, b, c, a, b, c, a, b, c, a);
}

References a, and currentPalette.

Referenced by ChangePalettePeriodically3().

Here is the caller graph for this function:

SetupVariablePalette5()

void SetupVariablePalette5	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d,
		CRGB	e )

{
  currentPalette = CRGBPalette16(a, b, c, d, e, a, b, c, d, e, a, b, c, d, e, a);
}

References a, and currentPalette.

Referenced by ChangePalettePeriodically3().

Here is the caller graph for this function:

SetupVariablePalette6()

void SetupVariablePalette6	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d,
		CRGB	e,
		CRGB	f )

{
  currentPalette = CRGBPalette16(a, b, c, d, e, f, a, b, c, d, e, f, a, b, c, d);
}

References a, currentPalette, and f.

SetupVariablePalette7()

void SetupVariablePalette7	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d,
		CRGB	e,
		CRGB	f,
		CRGB	g )

{
  currentPalette = CRGBPalette16(a, b, c, d, e, f, g, a, b, c, d, e, f, g, a, b);
}

References a, currentPalette, and f.

SetupVariableStripes()

void SetupVariableStripes	(	CRGB	a,
		CRGB	b,
		CRGB	c,
		CRGB	d )

{
 
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = a;
  }
}

References a, leds, and NUM_LEDS.

Variable Documentation

PROGMEM

const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM

Initial value:

=
{
  CRGB::Red,
  CRGB::Gray, 
  CRGB::Blue,
  CRGB::Black,
 
  CRGB::Red,
  CRGB::Gray,
  CRGB::Blue,
  CRGB::Black,
 
  CRGB::Red,
  CRGB::Red,
  CRGB::Gray,
  CRGB::Gray,
  CRGB::Blue,
  CRGB::Blue,
  CRGB::Black,
  CRGB::Black
}

{
  CRGB::Red,
  CRGB::Gray, // 'white' is too bright compared to red and blue
  CRGB::Blue,
  CRGB::Black,
 
  CRGB::Red,
  CRGB::Gray,
  CRGB::Blue,
  CRGB::Black,
 
  CRGB::Red,
  CRGB::Red,
  CRGB::Gray,
  CRGB::Gray,
  CRGB::Blue,
  CRGB::Blue,
  CRGB::Black,
  CRGB::Black
};