├── .gitignore
├── LICENSE
├── README.md
├── breadboard.fzz
├── breadboard.png
└── fastled-patterns.ino


/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Resseguie/FastLED-Patterns/c51362f68898a28f504f0bc3ee0909640bc3033d/.gitignore


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 David Resseguie
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | A bunch of sample color patterns using FastLED library for controlling LED strips such as Adafruit Neopixels.
2 | 
3 | You'll need to have the FastLED library installed: http://fastled.io/
4 | 
5 | Depending on your specific LED strip, you'll need to be sure you power it appropriately. If you're using the Adafruit Neopixels like I am, they have a lot of information and best practices you'll want to read: https://learn.adafruit.com/adafruit-neopixel-uberguide/best-practices
6 | 
7 | Here is my setup if it helps you get started.
8 | 
9 | ![Sample Breadboard](https://raw.github.com/Resseguie/FastLED-patterns/master/breadboard.png)


--------------------------------------------------------------------------------
/breadboard.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Resseguie/FastLED-Patterns/c51362f68898a28f504f0bc3ee0909640bc3033d/breadboard.fzz


--------------------------------------------------------------------------------
/breadboard.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Resseguie/FastLED-Patterns/c51362f68898a28f504f0bc3ee0909640bc3033d/breadboard.png


--------------------------------------------------------------------------------
/fastled-patterns.ino:
--------------------------------------------------------------------------------
  1 | #include "FastLED.h"
  2 | 
  3 | // How many leds in your strip?
  4 | #define NUM_LEDS 240
  5 | #define DATA_PIN 6
  6 | #define FORWARD 0
  7 | #define BACKWARD 1
  8 | #define SLOW 250
  9 | #define MEDIUM 50
 10 | #define FAST 5
 11 | 
 12 | CRGB leds[NUM_LEDS];
 13 | 
 14 | boolean direction = FORWARD;
 15 | 
 16 | void setup() { 
 17 |   FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
 18 |   randomSeed(analogRead(0));
 19 |   Serial.begin(9600);
 20 | }
 21 | 
 22 | void loop() { 
 23 | 
 24 |   rainbow(0,NULL);
 25 |   delay(3000);
 26 |   colorWipe(CRGB::Black,FORWARD,FAST);
 27 |   allRandom();
 28 |   delay(3000);
 29 |   disolve(15,100,MEDIUM);
 30 | 
 31 |   for(int i=0; i<3; i++){
 32 |     CRGB c1 = randomColor();
 33 |     CRGB c2 = randomColor();
 34 |     stripes(c1,c2,5);
 35 |     delay(2000);
 36 |     stripes(c2,c1,5);
 37 |     delay(2000);
 38 |   }
 39 | 
 40 |   for(int i=0; i<2; i++){
 41 |     cylon(randomColor(), 10,FAST);
 42 |   }
 43 | 
 44 | 
 45 |   lightning(NULL,15,50,MEDIUM);
 46 |   lightning(CRGB::White,20,50,MEDIUM);
 47 | 
 48 |   for(int i=0; i<3; i++){
 49 |     theaterChase(randomColor(),10,SLOW);
 50 |   }
 51 | 
 52 |   theaterChaseRainbow(1,MEDIUM);
 53 | 
 54 |   rainbow(FAST,1);
 55 | 
 56 |   flash(randomColor(),10,SLOW);
 57 | 
 58 |   flash(NULL,50,MEDIUM);
 59 | 
 60 |   for(int i=0; i<2; i++){ 
 61 |     colorWipe(randomColor(),FAST,direction);
 62 |     direction = !direction;
 63 |   }
 64 | 
 65 | 
 66 | }
 67 | 
 68 | // Changes all LEDS to given color
 69 | void allColor(CRGB c){
 70 |   for(int i=0; i<NUM_LEDS; i++){
 71 |     leds[i] = c;
 72 |   }
 73 |   FastLED.show();
 74 | }
 75 | 
 76 | void allRandom(){
 77 |   for(int i=0; i<NUM_LEDS; i++){
 78 |     leds[i] = randomColor();
 79 |   }
 80 |   FastLED.show(); 
 81 | }
 82 | 
 83 | // Random disolve colors
 84 | void disolve(int simultaneous, int cycles, int speed){
 85 |   for(int i=0; i<cycles; i++){
 86 |     for(int j=0; j<simultaneous; j++){
 87 |       int idx = random(NUM_LEDS);
 88 |       leds[idx] = CRGB::Black;
 89 |     }
 90 |     FastLED.show();
 91 |     delay(speed);
 92 |   }
 93 | 
 94 |   allColor(CRGB::Black);
 95 | }
 96 | 
 97 | // Flashes given color
 98 | // If c==NULL, random color flash
 99 | void flash(CRGB c, int count, int speed){
100 |   for(int i=0; i<count; i++){
101 |     if(c){
102 |       allColor(c);
103 |     }
104 |     else{
105 |       allColor(randomColor());
106 |     }
107 |     delay(speed);
108 |     allColor(CRGB::Black);
109 |     delay(speed);
110 |   }
111 | }
112 | 
113 | // Wipes color from end to end
114 | void colorWipe(CRGB c, int speed, int direction){
115 |   for(int i=0; i<NUM_LEDS; i++){
116 |     if(direction == FORWARD){
117 |       leds[i] = c;
118 |     }
119 |     else{
120 |       leds[NUM_LEDS-1-i] = c;
121 |     }
122 |     FastLED.show();
123 |     delay(speed);
124 |   }
125 | }
126 | 
127 | // Rainbow colors that slowly cycle across LEDs
128 | void rainbow(int cycles, int speed){ // TODO direction
129 |   if(cycles == 0){
130 |     for(int i=0; i< NUM_LEDS; i++) {
131 |       leds[i] = Wheel(((i * 256 / NUM_LEDS)) & 255);
132 |     }
133 |     FastLED.show();
134 |   }
135 |   else{
136 |     for(int j=0; j<256*cycles; j++) {
137 |       for(int i=0; i< NUM_LEDS; i++) {
138 |         leds[i] = Wheel(((i * 256 / NUM_LEDS) + j) & 255);
139 |       }
140 |       FastLED.show();
141 |       delay(speed);
142 |     }
143 |   }
144 | }
145 | 
146 | // Theater-style crawling lights
147 | void theaterChase(CRGB c, int cycles, int speed){ // TODO direction
148 | 
149 |   for (int j=0; j<cycles; j++) {  
150 |     for (int q=0; q < 3; q++) {
151 |       for (int i=0; i < NUM_LEDS; i=i+3) {
152 |         int pos = i+q;
153 |         leds[pos] = c;    //turn every third pixel on
154 |       }
155 |       FastLED.show();
156 | 
157 |       delay(speed);
158 | 
159 |       for (int i=0; i < NUM_LEDS; i=i+3) {
160 |         leds[i+q] = CRGB::Black;        //turn every third pixel off
161 |       }
162 |     }
163 |   }
164 | }
165 | 
166 | // Theater-style crawling lights with rainbow effect
167 | void theaterChaseRainbow(int cycles, int speed){ // TODO direction, duration
168 |   for (int j=0; j < 256 * cycles; j++) {     // cycle all 256 colors in the wheel
169 |     for (int q=0; q < 3; q++) {
170 |       for (int i=0; i < NUM_LEDS; i=i+3) {
171 |         int pos = i+q;
172 |         leds[pos] = Wheel( (i+j) % 255);    //turn every third pixel on
173 |       }
174 |       FastLED.show();
175 | 
176 |       delay(speed);
177 | 
178 |       for (int i=0; i < NUM_LEDS; i=i+3) {
179 |         leds[i+q] = CRGB::Black;  //turn every third pixel off
180 |       }
181 |     }
182 |   }
183 | }
184 | 
185 | // Random flashes of lightning
186 | void lightning(CRGB c, int simultaneous, int cycles, int speed){
187 |   int flashes[simultaneous];
188 | 
189 |   for(int i=0; i<cycles; i++){
190 |     for(int j=0; j<simultaneous; j++){
191 |       int idx = random(NUM_LEDS);
192 |       flashes[j] = idx;
193 |       leds[idx] = c ? c : randomColor();
194 |     }
195 |     FastLED.show();
196 |     delay(speed);
197 |     for(int s=0; s<simultaneous; s++){
198 |       leds[flashes[s]] = CRGB::Black;
199 |     }
200 |     delay(speed);
201 |   }
202 | }
203 | 
204 | // Sliding bar across LEDs
205 | void cylon(CRGB c, int width, int speed){
206 |   // First slide the leds in one direction
207 |   for(int i = 0; i <= NUM_LEDS-width; i++) {
208 |     for(int j=0; j<width; j++){
209 |       leds[i+j] = c;
210 |     }
211 | 
212 |     FastLED.show();
213 | 
214 |     // now that we've shown the leds, reset to black for next loop
215 |     for(int j=0; j<5; j++){
216 |       leds[i+j] = CRGB::Black;
217 |     }
218 |     delay(speed);
219 |   }
220 | 
221 |   // Now go in the other direction.  
222 |   for(int i = NUM_LEDS-width; i >= 0; i--) {
223 |     for(int j=0; j<width; j++){
224 |       leds[i+j] = c;
225 |     }
226 |     FastLED.show();
227 |     for(int j=0; j<width; j++){
228 |       leds[i+j] = CRGB::Black;
229 |     }
230 | 
231 |     delay(speed);
232 |   }
233 | }
234 | 
235 | // Display alternating stripes
236 | void stripes(CRGB c1, CRGB c2, int width){
237 |   for(int i=0; i<NUM_LEDS; i++){
238 |     if(i % (width * 2) < width){
239 |       leds[i] = c1;
240 |     }
241 |     else{
242 |       leds[i] = c2;
243 |     } 
244 |   }
245 |   FastLED.show();
246 | }
247 | 
248 | // Theater-style crawling of stripes
249 | void stripesChase(CRGB c1, CRGB c2, int width, int cycles, int speed){ // TODO direction
250 | 
251 | }
252 | 
253 | // Input a value 0 to 255 to get a color value.
254 | // The colours are a transition r - g - b - back to r.
255 | CRGB Wheel(byte WheelPos) {
256 |   if(WheelPos < 85) {
257 |     return CRGB(WheelPos * 3, 255 - WheelPos * 3, 0);
258 |   } 
259 |   else if(WheelPos < 170) {
260 |     WheelPos -= 85;
261 |     return CRGB(255 - WheelPos * 3, 0, WheelPos * 3);
262 |   } 
263 |   else {
264 |     WheelPos -= 170;
265 |     return CRGB(0, WheelPos * 3, 255 - WheelPos * 3);
266 |   }
267 | }
268 | 
269 | CRGB randomColor(){
270 |   return Wheel(random(256)); 
271 | }
272 | 
273 | 
274 | 
275 | 
276 | 
277 | 
278 | 
279 | 
280 | 
281 | 
282 | 
283 | 
284 | 
285 | 
286 | 
287 | 
288 | 
289 | 


--------------------------------------------------------------------------------