leds.ino
#include "FastLED.h"
#include <Wire.h>
// Number of RGB LEDs in the strand
#define NUM_LEDS 60
#define BRIGHTNESS 64
#define LED_TYPE WS2811
#define COLOR_ORDER GRB
// Define the array of leds
CRGB leds[NUM_LEDS];
// Arduino pin used for Data
#define PIN 6
CRGBPalette16 currentPalette;
TBlendType currentBlending;
uint8_t startIndex = 0;
#define UPDATES_PER_SECOND 100
extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
uint8_t starthue = 0;
void ChangePalettePeriodically();
void FillLEDsFromPaletteColors(uint8_t colorIndex);
void SetupBlackAndWhiteStripedPalette();
void SetupPurpleAndGreenPalette();
void SetupTotallyRandomPalette();
const int SLAVE_ADDRESS = 0x06;
enum State
{
STATE_OK = 0,
STATE_UNKNOWN_COMMAND,
STATE_UNKNOWN_MODE,
STATE_WRONG_BYTECOUNT
};
int i2c_state = STATE_OK;
enum Mode
{
MODE_CYCLE, // 0
MODE_GROWING_BARS,
MODE_FADE,
MODE_CHASE,
MODE_CHASE_MULTI,
MODE_PERIODIC_PALETTE, // 5
MODE_RAINBOW,
MODE_RAINBOW_GLITTER,
MODE_CYLON,
MODE_BOUNCE,
MODE_CONFETTI, // 10
MODE_SINELON,
MODE_BPM,
MODE_JUGGLE,
MODE_FIRE,
MODE_LAST
};
uint8_t BeatsPerMinute = 62;
Mode mode = MODE_PERIODIC_PALETTE;
Mode old_mode = static_cast<Mode>(-1);
void receiveData(int byteCount)
{
int c = Wire.read();
switch (c)
{
case 0:
// Read status
if (byteCount != 1)
{
while (--byteCount)
Wire.read();
i2c_state = STATE_WRONG_BYTECOUNT;
}
break;
case 1:
// Set mode
if (byteCount != 2)
{
while (--byteCount)
Wire.read();
i2c_state = STATE_WRONG_BYTECOUNT;
return;
}
mode = static_cast<Mode>(Wire.read());
i2c_state = STATE_OK;
if (mode >= MODE_LAST)
i2c_state = STATE_UNKNOWN_MODE;
break;
default:
while (--byteCount)
Wire.read();
i2c_state = STATE_UNKNOWN_COMMAND;
break;
}
}
void sendData()
{
Wire.write(i2c_state);
}
void setup()
{
FastLED.addLeds<WS2811, PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
FastLED.setBrightness(BRIGHTNESS);
currentPalette = RainbowColors_p;
currentBlending = LINEARBLEND;
Serial.begin(57600);
Serial.println("LED Controller v 0.1");
Wire.begin(SLAVE_ADDRESS);
Wire.onReceive(receiveData);
Wire.onRequest(sendData);
}
const static CRGB chase_colours[] = {
CRGB::Yellow, CRGB::Green, CRGB::HotPink, CRGB::Blue, CRGB::Red, CRGB::White
};
void fadeall()
{
for (int i = 0; i < NUM_LEDS; i++)
leds[i].nscale8(250);
}
void addGlitter(fract8 chanceOfGlitter)
{
if (random8() < chanceOfGlitter)
{
leds[random16(NUM_LEDS)] += CRGB::White;
}
}
const int BUF_SIZE = 20;
int index = 0;
char buffer[BUF_SIZE];
int current_led = 0;
int current_loop = 0;
bool growing = true;
// Fire2012 by Mark Kriegsman, July 2012
// as part of "Five Elements" shown here: http://youtu.be/knWiGsmgycY
////
// This basic one-dimensional 'fire' simulation works roughly as follows:
// There's a underlying array of 'heat' cells, that model the temperature
// at each point along the line. Every cycle through the simulation,
// four steps are performed:
// 1) All cells cool down a little bit, losing heat to the air
// 2) The heat from each cell drifts 'up' and diffuses a little
// 3) Sometimes randomly new 'sparks' of heat are added at the bottom
// 4) The heat from each cell is rendered as a color into the leds array
// The heat-to-color mapping uses a black-body radiation approximation.
//
// Temperature is in arbitrary units from 0 (cold black) to 255 (white hot).
//
// This simulation scales it self a bit depending on NUM_LEDS; it should look
// "OK" on anywhere from 20 to 100 LEDs without too much tweaking.
//
// I recommend running this simulation at anywhere from 30-100 frames per second,
// meaning an interframe delay of about 10-35 milliseconds.
//
// Looks best on a high-density LED setup (60+ pixels/meter).
//
//
// There are two main parameters you can play with to control the look and
// feel of your fire: COOLING (used in step 1 above), and SPARKING (used
// in step 3 above).
//
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames. More cooling = shorter flames.
// Default 50, suggested range 20-100
#define COOLING 55
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire. Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
#define SPARKING 120
bool gReverseDirection = false;
void Fire2012()
{
// Array of temperature readings at each simulation cell
static byte heat[NUM_LEDS];
// Step 1. Cool down every cell a little
for( int i = 0; i < NUM_LEDS; i++) {
heat[i] = qsub8( heat[i], random8(0, ((COOLING * 10) / NUM_LEDS) + 2));
}
// Step 2. Heat from each cell drifts 'up' and diffuses a little
for( int k= NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;
}
// Step 3. Randomly ignite new 'sparks' of heat near the bottom
if( random8() < SPARKING ) {
int y = random8(7);
heat[y] = qadd8( heat[y], random8(160,255) );
}
// Step 4. Map from heat cells to LED colors
for( int j = 0; j < NUM_LEDS; j++) {
CRGB color = HeatColor( heat[j]);
int pixelnumber;
if( gReverseDirection ) {
pixelnumber = (NUM_LEDS-1) - j;
} else {
pixelnumber = j;
}
leds[pixelnumber] = color;
}
}
#define CHECK_MODE() \
if (mode != old_mode) \
{ \
old_mode = mode; \
current_led = current_loop = 0; \
break; \
}
void loop()
{
if (Serial.available())
{
// Command from PC
char c = Serial.read();
if ((c == '\r') || (c == '\n'))
{
buffer[index] = 0;
index = 0;
mode = static_cast<Mode>(atoi(buffer));
memset(leds, 0, NUM_LEDS * 3);
current_led = 0;
current_loop = 0;
Serial.print("Mode ");
Serial.println(mode);
}
else
{
if (index >= BUF_SIZE)
{
Serial.println("MOTOR: Error: Line too long");
index = 0;
return;
}
buffer[index++] = c;
}
}
switch (mode)
{
case MODE_CYCLE:
// one at a time
if (current_loop >= 3)
current_loop = 0;
if (current_led >= NUM_LEDS)
{
current_led = 0;
++current_loop;
}
memset(leds, 0, NUM_LEDS * 3);
switch(current_loop) {
case 0: leds[current_led].r = 255; break;
case 1: leds[current_led].g = 255; break;
case 2: leds[current_led].b = 255; break;
}
++current_led;
break;
case MODE_GROWING_BARS:
// growing/receeding bars
if (current_led >= NUM_LEDS)
{
current_led = 0;
++current_loop;
}
if (growing)
{
if (current_loop >= 3)
{
current_loop = 0;
growing = false;
break;
}
switch (current_loop)
{
case 0: leds[current_led].r = 255; break;
case 1: leds[current_led].g = 255; break;
case 2: leds[current_led].b = 255; break;
}
}
else
{
if (current_loop >= 3)
{
current_loop = 0;
growing = true;
break;
}
switch (current_loop)
{
case 0: leds[NUM_LEDS-1-current_led].r = 0; break;
case 1: leds[NUM_LEDS-1-current_led].g = 0; break;
case 2: leds[NUM_LEDS-1-current_led].b = 0; break;
}
}
++current_led;
break;
case MODE_FADE:
// Fade in/fade out
for (int j = 0; j < 3; j++ ) {
memset(leds, 0, NUM_LEDS * 3);
for(int k = 0; k < 256; k++) {
for(int i = 0; i < NUM_LEDS; i++ ) {
switch(j) {
case 0: leds[i].r = k; break;
case 1: leds[i].g = k; break;
case 2: leds[i].b = k; break;
}
}
FastLED.show();
delay(3);
CHECK_MODE();
}
for(int k = 255; k >= 0; k--) {
for(int i = 0; i < NUM_LEDS; i++ ) {
switch(j) {
case 0: leds[i].r = k; break;
case 1: leds[i].g = k; break;
case 2: leds[i].b = k; break;
}
}
FastLED.show();
delay(3);
CHECK_MODE();
}
}
break;
case MODE_CHASE:
memset(leds, 0, NUM_LEDS * 3);
for (size_t c = 0; c < sizeof(chase_colours)/sizeof(chase_colours[0]); ++c)
{
for (int i = 0; i < NUM_LEDS; ++i)
{
if (i)
leds[i-1] = CRGB::Black;
leds[i] = chase_colours[c];
FastLED.show();
delay(50);
CHECK_MODE();
}
leds[NUM_LEDS-1] = CRGB::Black;
}
break;
case MODE_BOUNCE:
for (size_t c = 0; c < sizeof(chase_colours)/sizeof(chase_colours[0]); ++c)
{
memset(leds, 0, NUM_LEDS * 3);
FastLED.show();
for (int i = 0; i < NUM_LEDS; ++i)
{
if (i)
leds[i-1] = CRGB::Black;
leds[i] = chase_colours[c];
FastLED.show();
delay(50);
CHECK_MODE();
}
leds[NUM_LEDS-1] = CRGB::Black;
FastLED.show();
delay(50);
for (int i = 0; i < NUM_LEDS; ++i)
{
if (i)
leds[NUM_LEDS-i] = CRGB::Black;
leds[NUM_LEDS-1-i] = chase_colours[c];
FastLED.show();
delay(50);
CHECK_MODE();
}
leds[NUM_LEDS-1] = CRGB::Black;
}
break;
case MODE_CHASE_MULTI:
memset(leds, 0, NUM_LEDS * 3);
for (size_t c = 0; c < sizeof(chase_colours)/sizeof(chase_colours[0]); ++c)
{
const int N = 4;
for (int j = 0; j < N; ++j)
{
memset(leds, 0, NUM_LEDS * 3);
for (int i = 0; i < NUM_LEDS; ++i)
{
if (((i+j) % N) == 0)
leds[i] = chase_colours[c];
}
FastLED.show();
delay(100);
CHECK_MODE();
}
leds[NUM_LEDS-1] = CRGB::Black;
}
break;
case MODE_PERIODIC_PALETTE:
ChangePalettePeriodically();
startIndex = startIndex + 1; /* motion speed */
FillLEDsFromPaletteColors(startIndex);
break;
case MODE_RAINBOW:
fill_rainbow(leds, NUM_LEDS, --starthue, 20);
break;
case MODE_RAINBOW_GLITTER:
fill_rainbow(leds, NUM_LEDS, --starthue, 20);
addGlitter(80);
break;
case MODE_CYLON:
if (current_led >= NUM_LEDS)
current_led = 0;
// Set the i'th led to red
leds[current_led] = CHSV(starthue++, 255, 255);
// Show the leds
FastLED.show();
fadeall();
// Wait a little bit before we loop around and do it again
FastLED.delay(10);
++current_led;
break;
case MODE_CONFETTI:
// random colored speckles that blink in and fade smoothly
{
fadeToBlackBy(leds, NUM_LEDS, 10);
int pos = random16(NUM_LEDS);
leds[pos] += CHSV(starthue + random8(64), 200, 255);
}
break;
case MODE_SINELON:
// a colored dot sweeping back and forth, with fading trails
{
fadeToBlackBy(leds, NUM_LEDS, 20);
int pos = beatsin16(13, 0, NUM_LEDS);
leds[pos] += CHSV(starthue, 255, 192);
}
break;
case MODE_BPM:
// colored stripes pulsing at a defined Beats-Per-Minute (BPM)
{
uint8_t beat = beatsin8(BeatsPerMinute, 64, 255);
for (int i = 0; i < NUM_LEDS; i++)
leds[i] = ColorFromPalette(PartyColors_p, starthue+(i*2), beat-starthue+(i*10));
}
break;
case MODE_JUGGLE:
// eight colored dots, weaving in and out of sync with each other
{
fadeToBlackBy(leds, NUM_LEDS, 20);
byte dothue = 0;
for(int i = 0; i < 8; i++)
{
leds[beatsin16(i+7,0,NUM_LEDS)] |= CHSV(dothue, 200, 255);
dothue += 32;
}
}
break;
case MODE_FIRE:
Fire2012();
break;
default:
memset(leds, 0, NUM_LEDS * 3);
FastLED.show();
break;
}
FastLED.show();
FastLED.delay(1000 / UPDATES_PER_SECOND);
EVERY_N_MILLISECONDS(20)
{
++starthue;
}
}
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;
}
}
// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly. All are shown here.
void ChangePalettePeriodically()
{
// Change palette every 8 seconds
const int secondHand = millis()/8000;
static int lastSecond = 999;
if(lastSecond != secondHand) {
lastSecond = secondHand;
const int pal = random(11);
switch (pal)
{
case 0: currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; break;
case 1: currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; break;
case 2: currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; break;
case 3: SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; break;
case 4: SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; break;
case 5: SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; break;
case 6: SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; break;
case 7: currentPalette = CloudColors_p; currentBlending = LINEARBLEND; break;
case 8: currentPalette = PartyColors_p; currentBlending = LINEARBLEND; break;
case 9: currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; break;
case 10: currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; break;
}
}
}
// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
{
for(int i = 0; i < 16; i++) {
currentPalette[i] = CHSV(random8(), 255, random8());
}
}
// This function sets up a palette of black and white stripes,
// using code. Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
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;
}
// This function sets up a palette of purple and green stripes.
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 );
}
// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM. A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
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
};
