1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

#include <FastLED.h>

#define LED_PIN     12
#define TAIL_PIN    6
#define NUM_LEDS    20       //Number of LEDs in the front
#define NUM_TAIL    15       //Number of LEDs in the tail
#define NUM_BALL    4        //Number of LEDs in the ball 

#define BRIGHTNESS  255      
#define LED_TYPE    WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
CRGB tail[NUM_TAIL];



#define UPDATES_PER_SECOND 100

// This example shows how to cross-fade between different color palettes
// using the function nblendPaletteTowardPalette.
//
// The basic idea is that you always have a "current palette" that you're
// pulling colors from with ColorFromPalette, and you have a "target palette"
// which is the 'next' palette that you want to get to.
// 
// After that, implementation is relatively simple: just periodically call
//   nblendPaletteTowardPalette( currentPalette, targetPalette);
// If the current palette is not yet equal to the target palette, this 
// function will make a few small changes to the current palette to make
// it slightly more like the target.  Over time, the current palette will
// come to be equal to the target.
// There's no need to test the current and target for equality; it's safe
// to keep calling nblendPaletteTowardPalette even after current reaches target.
// For faster blending, call nblendPaletteTowardPalette twice per loop.




void setup() {
  delay( 3000 ); // power-up safety delay
  FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.addLeds<LED_TYPE, TAIL_PIN, COLOR_ORDER>(tail, NUM_TAIL).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(  BRIGHTNESS );
}


//COLOR PALETTES:  Here are several different ways to set up custom color palettes.  More info can be found at http://fastled.io/docs/3.1/group___colorpalletes.html
// Several palettes come pre-defined with FastLED: RainbowColors_p, ForestColors_p, OceanColors_p, HeatColors_p, LavaColors_p, RainbowStripeColors_p 
// so feel free to use those without needing to define them here.  
// Much more info and a list of color definititions can be found at https://github.com/FastLED/FastLED/wiki/Pixel-reference#chsv


// A red and white striped palette -- RedWhite_p
// "CRGB::Gray" is used as white to keep the brightness more uniform.
const TProgmemRGBPalette16 RedOrange_p FL_PROGMEM =
{  CRGB::Red,  CRGB::Red,  CRGB::Red,  CRGB::Red, 
   CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Orange,
   CRGB::Red,  CRGB::Red,  CRGB::Red,  CRGB::Red, 
   CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Orange };


   // A mostly green and dark green palette.  Greens_p
const TProgmemRGBPalette16 Greens_p FL_PROGMEM =
{  CRGB::Green, CRGB::Green, CRGB::DarkGreen, CRGB::DarkGreen, 
   CRGB::Green, CRGB::Green, CRGB::DarkGreen, CRGB::DarkGreen,
   CRGB::Green, CRGB::Green, CRGB::DarkGreen, CRGB::DarkGreen,
   CRGB::Green, CRGB::Green, CRGB::DarkGreen, CRGB::DarkGreen, };

// A pure "fairy light" palette with some brightness variations  FairyLight_p
#define HALFFAIRY ((CRGB::FairyLight & 0xFEFEFE) / 2)
#define QUARTERFAIRY ((CRGB::FairyLight & 0xFCFCFC) / 4)
const TProgmemRGBPalette16 FairyLight_p FL_PROGMEM =
{  CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight, 
   HALFFAIRY,        HALFFAIRY,        CRGB::FairyLight, CRGB::FairyLight, 
   QUARTERFAIRY,     QUARTERFAIRY,     CRGB::FairyLight, CRGB::FairyLight, 
   CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight };

// A palette of soft snowflakes with the occasional bright one
const TProgmemRGBPalette16 Snow_p FL_PROGMEM =
{  0x304048, 0x304048, 0x304048, 0x304048,
   0x304048, 0x304048, 0x304048, 0x304048,
   0x304048, 0x304048, 0x304048, 0x304048,
   0x304048, 0x304048, 0x304048, 0xE0F0FF };

// A black "off" palette  Black_p;
const TProgmemRGBPalette16 Black_p FL_PROGMEM =
{  CRGB::Black};

// little twinkles
const TProgmemRGBPalette16 Twinkles_p FL_PROGMEM =
{  CRGB::Black, CRGB::Black, CRGB::Black, CRGB::Black, 
   CRGB::Black, CRGB::Black, CRGB::Black, CRGB::Black,
   CRGB::Gray, CRGB::Black, CRGB::Black, CRGB::Black,
   CRGB::White, CRGB::Black, CRGB::Black, CRGB::Black };

   // purple blue
const TProgmemRGBPalette16 Purples_p FL_PROGMEM =
{  CRGB::Purple, CRGB::Magenta, CRGB::Blue, CRGB::DarkBlue, 
   CRGB::Purple, CRGB::Magenta, CRGB::Blue, CRGB::DarkBlue,
   CRGB::Purple, CRGB::Magenta, CRGB::Blue, CRGB::DarkBlue, 
   CRGB::Purple, CRGB::Magenta, CRGB::Blue, CRGB::DarkBlue };


//define starting palettes here

CRGBPalette16 currentPalette( CRGB::Black);
CRGBPalette16 tailPalette(CRGB::Black);

CRGBPalette16 targetPalette( RedOrange_p );
CRGBPalette16 tailtargetPalette( Greens_p );


void loop()
{  ball();
  ChangePalettePeriodically();

  // Crossfade current palette slowly toward the target palette
  //
  // Each time that nblendPaletteTowardPalette is called, small changes
  // are made to currentPalette to bring it closer to matching targetPalette.
  // You can control how many changes are made in each call:
  //   - the default of 24 is a good balance
  //   - meaningful values are 1-48.  1=veeeeeeeery slow, 48=quickest
  //   - "0" means do not change the currentPalette at all; freeze
  
  uint8_t maxChanges = 24; 
  nblendPaletteTowardPalette( currentPalette, targetPalette, maxChanges);
  nblendPaletteTowardPalette( tailPalette, tailtargetPalette, maxChanges);

  static uint8_t startIndex = 0;
  startIndex = startIndex + 1; /* motion speed */
  FillLEDsFromPaletteColors( startIndex);

  FastLED.show();
  FastLED.delay(1000 / UPDATES_PER_SECOND);
}

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
  uint8_t brightness = 120;          //You can change the brightness of the front and the tail independenty.
  uint8_t brightnesstail = 255;       // On my hat, having the tail brighter makes the hat look more balanced.
  
  for( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette( currentPalette, colorIndex + sin8(i*16), brightness);
    colorIndex += 3;
  }

  for( int t = 0; t < (NUM_TAIL-NUM_BALL); t++) {
    tail[t] = ColorFromPalette( tailPalette, colorIndex + sin8(t*16), brightnesstail);
    colorIndex += 3;
  }
}

//Set up your playlist here

void ChangePalettePeriodically()
{
  uint8_t secondHand = (millis() / 1000) % 225;
  static uint8_t lastSecond = 250;
  
  if( lastSecond != secondHand) {
    lastSecond = secondHand;

     if( secondHand == 5)  { targetPalette = RedOrange_p; tailtargetPalette = Greens_p; }  // red and green Elf
     if( secondHand == 23)  { targetPalette = Black_p; tailtargetPalette = Black_p;} //fade through black
     if( secondHand == 25)  { targetPalette = RainbowColors_p; tailtargetPalette = RainbowColors_p; } //Rainbow
     if( secondHand == 50)  { targetPalette = CloudColors_p; tailtargetPalette = CloudColors_p;} //Clouds
     if( secondHand == 75)  { targetPalette = Twinkles_p; tailtargetPalette = FairyLight_p;} //Fairy lights & Twinkles
     if( secondHand == 100)  { targetPalette = ForestColors_p; tailtargetPalette = OceanColors_p; }  // Green and blue
     if( secondHand == 125)  { targetPalette = FairyLight_p; tailtargetPalette = Greens_p; } // White and red "Santa"
     if( secondHand == 147)  { targetPalette = Black_p; tailtargetPalette = Black_p;} //fade through black
     if( secondHand == 150)  { targetPalette = Snow_p; tailtargetPalette = RedOrange_p;} //Green and white elf
     if( secondHand == 175)  { targetPalette = Purples_p; tailtargetPalette = Purples_p;} //Purple palette
     if( secondHand == 200)  { targetPalette = Twinkles_p; tailtargetPalette = Twinkles_p;}  //twinkles
  }
}

void ball(){

for (uint8_t b = (NUM_TAIL - NUM_BALL); b < NUM_TAIL; b++)
tail[b] = CHSV(160, 0, 200);   
  
FastLED.show();
}