Hi all! I’m somewhat new, and I know I’m basically a hack with Arduino, but my needs have been simple and I’m really enjoying the projects I’m seeing here. I do have a question on my first fastled sketch.
I am in a performance dog-show group Rock-n-Roll K9s ( Rock N Roll K9's Performance Team ) where at our shows we often have need for different color bandanas and other color-coded items in our skits. I have an idea to make a fast LED collar to toggle through a series of color setups needed in a particular skit.
Using the “ColorPallette” example sketch, I have been able to modify it to use the primarily red-white-blue, red-sweeping, blue-sweeping, Red-white (go Canada!). The attached code as a lot of REMed out lines and will eventually be streamlined to just the few different setups we need.
Here is my ONLY problem thus far. Can anyone recommend (by example if possible) how I can add a momentary push-button switch to toggle between the different setups (likely only 5 or 6). My thought is when turning on the collar setup 1 is the default, then the pushbutton can be pressed the number of times to get to the one we would like.
It would be nice to be able to turn off the collar to save battery and have the last setting be remembered – but if that requires any additional hardware, I don’t have a lot of room in the little control box that will hold the 680mah hour battery, the arduino pro-mini, and a micro-usb charger - 5V up converter).
I know I could make my own custom PCB, but with all the individual pieces available for very cheap, I can live with parts wired and stuffed in the small box.
So, attached is my cobbled code, and if anyone could help, I would appreciate it.
Thanks,
Roger
Code
#include <FastLED.h>
#define LED_PIN 6
#define NUM_LEDS 27
#define BRIGHTNESS 64
#define LED_TYPE WS2812
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
#define UPDATES_PER_SECOND 100
// This example shows several ways to set up and use ‘palettes’ of colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code. Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract ‘theory and practice’ of
// FastLED compact palettes are at the bottom of this file.
CRGBPalette16 currentPalette;
TBlendType currentBlending;
extern CRGBPalette16 myRedWhiteBluePalette;
extern CRGBPalette16 myCanadian2Palette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
extern const TProgmemPalette16 myCanadian2Palette_p PROGMEM;
void setup() {
delay( 3000 ); // power-up safety delay
FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
FastLED.setBrightness( BRIGHTNESS );
currentPalette = RainbowColors_p;
currentBlending = BLEND;
}
void loop()
{
ChangePalettePeriodically();
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 = 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()
{
uint8_t secondHand = (millis() / 1000) % 60;
static uint8_t lastSecond = 99;
if( lastSecond != secondHand) {
lastSecond = secondHand;
// if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = BLEND; }
// if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
// if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = BLEND; }
if( secondHand == 20) { SetupBlackAndRedStripedPalette(); currentBlending = BLEND; }
// if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = BLEND; }
if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
if( secondHand == 40) { SetupCanadianPalette(); currentBlending = NOBLEND; }
// if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = BLEND; }
if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
if( secondHand == 55) { currentPalette = myCanadian2Palette_p; currentBlending = NOBLEND; }
}
}
// 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 blue 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 BLUE.
currentPalette[0] = CRGB::Blue;
currentPalette[4] = CRGB::Blue;
currentPalette[8] = CRGB::Blue;
currentPalette[12] = CRGB::Blue;
}
// This function sets up a palette of black and Red 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 SetupBlackAndRedStripedPalette()
{
// ‘black out’ all 16 palette entries…
fill_solid( currentPalette, 16, CRGB::Black);
// and set every fourth one to Red.
currentPalette[0] = CRGB::Red;
currentPalette[4] = CRGB::Red;
currentPalette[8] = CRGB::Red;
currentPalette[12] = CRGB::Red;
}
// This function sets up a palette of Red and White (Canadian) 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 SetupCanadianPalette()
{
// ‘black out’ all 16 palette entries…
fill_solid( currentPalette, 16, CRGB::Gray);
// and set every fourth one to Red.
currentPalette[0] = CRGB::Red;
currentPalette[4] = CRGB::Red;
currentPalette[8] = CRGB::Black;
currentPalette[12] = CRGB::Black;
}
// 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
};
// This example shows how to set up a static color palette ‘myCanadian2’
// 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 myCanadian2Palette_p PROGMEM =
{
CRGB::Red,
CRGB::Gray, // ‘white’ is too bright compared to red and blue
CRGB::Red,
CRGB::Black,
CRGB::Red,
CRGB::Gray,
CRGB::Red,
CRGB::Black,
CRGB::Red,
CRGB::Red,
CRGB::Gray,
CRGB::Gray,
CRGB::Black,
CRGB::Black,
CRGB::Black,
CRGB::Black
};