Hi Again,
I have this now working beautifully with the two push button switches but and struggling a bit understanding what to change when I replace the push buttons with PIR sensors. If I use the code 'as is' with the sensors instead of switches there is no 'latching' effect and the LED's switch off after the built-in 2 second delay. A pointer or two would be much appriated.
// **** Push button state changer for 2 buttons ******
// v1.01 - First Iteration
// v1.02 - HIGH/LOW Swapped to correct on/off
// v2.01 - Add functions code for LED's
// v2.11 - Switch operates all leds
// v2.20 - Working Version (push buttons)
#include <FastLED.h>
//User Variables
#define NUM_LEDS 89
#define BRIGHTNESS 64
#define LED_Delay 2000
// ********* PIR/Switch Variables ******
const byte topButtonPin = 3; //switch
const byte bottomButtonPin = 2;//switch
const byte ledPin = 6;
enum states
{
IDLE,
GOING_DOWN,
GOING_UP
};
states currentState = IDLE;
// ********* FastLED Variables ******
#define FastLED_PIN 10
#define LED_TYPE WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
#define UPDATES_PER_SECOND 100
CRGBPalette16 currentPalette;
TBlendType currentBlending;
extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
void setup()
{
//Switch Setup
Serial.begin(115200);
pinMode(bottomButtonPin, INPUT_PULLUP);
pinMode(topButtonPin, INPUT_PULLUP);
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, LOW); //LED off initially
//FastLED Setup
delay( 3000 ); // power-up safety delay
FastLED.addLeds<LED_TYPE, FastLED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
FastLED.setBrightness( BRIGHTNESS );
leds[0] = CRGB::Blue;
leds[1] = CRGB::White;
FastLED.show();
delay(LED_Delay*.5);
FastLED.clear();
FastLED.show();
currentPalette = RainbowColors_p;
currentBlending = LINEARBLEND;
}
void loop()
{
switch (currentState)
{
case IDLE:
if (testTopButton())
{
digitalWrite(ledPin, HIGH); //LED on
Serial.println("moving to GOING_DOWN");
currentState = GOING_DOWN;
}
else if (testBottomButton())
{
digitalWrite(ledPin, HIGH); //LED on
Serial.println("moving to GOING_UP");
currentState = GOING_UP;
}
break;
case GOING_DOWN:
if (testBottomButton())
{
digitalWrite(ledPin, LOW); //LED off
Serial.println("moving to IDLE");
currentState = IDLE;
delay(LED_Delay);
FastLED.clear();
FastLED.show();
}
break;
case GOING_UP:
if (testTopButton())
{
digitalWrite(ledPin, LOW); //LED off
Serial.println("moving to IDLE");
currentState = IDLE;
delay(LED_Delay);
FastLED.clear();
FastLED.show();
}
break;
};
if (currentState == GOING_DOWN){
ChangePalettePeriodically();
static uint8_t startIndex = 0;
startIndex = startIndex + 1; /* motion speed */
FillLEDsFromPaletteColors( startIndex);
FastLED.show();
FastLED.delay(1000 / UPDATES_PER_SECOND);
}
if (currentState == GOING_UP){
ChangePalettePeriodically();
static uint8_t startIndex = 0;
startIndex = startIndex + 1; /* motion speed */
FillLEDsFromPaletteColors( startIndex);
FastLED.show();
FastLED.delay(1000 / UPDATES_PER_SECOND);
}
}
// ****** End of loop ******
// ****** Switch Functions ******
bool testTopButton()
{
bool becamePressed = false;
static byte prevTopButtonState = LOW;
byte currentTopButtonState = digitalRead(topButtonPin);
if (currentTopButtonState != prevTopButtonState && currentTopButtonState == LOW)
{
becamePressed = true;
}
prevTopButtonState = currentTopButtonState;
return becamePressed;
}
bool testBottomButton()
{
bool becamePressed = false;
static byte prevBottomButtonState = LOW;
byte currentBottomButtonState = digitalRead(bottomButtonPin);
if (currentBottomButtonState != prevBottomButtonState && currentBottomButtonState == LOW)
{
becamePressed = true;
}
prevBottomButtonState = currentBottomButtonState;
return becamePressed;
}
//**** FAST LedColour Pallette Functions *****
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 = LINEARBLEND; }
if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
}
}
// 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
};