WS2811 Neopixel RGB Waterproof Pixel LED Strip (Multicolour, 3-Inch)

Amazing Colorful RGB LED Clock

Hello friends, this is RGB LED clock. You will get the time in 12Hr format and changing color of number automatically. In this project we used WS2812B LED strip which is available in online market easily. Also you can change the time from key. Here you will get five no of key to set time and color pattern. If you want to make this then just follow all the step and make your own RGB LED clock.

Diagram :

Componants

Arduino Nano : https://amzn.to/37Qhz0e
WS2811 LED Chain : https://amzn.to/3kCFXWy
MT3608 Module : https://amzn.to/3uyHfXC
DC Socket : https://amzn.to/2HLNYtS
DS3231 Module :
PVC Sheet :

Code :

#include <Adafruit_NeoPixel.h>
#include <math.h>
#include <Wire.h>
#include "RTClib.h"
#include <Encoder.h>

#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 9

#define SEGMENTS_PER_DIGIT 7
#define LEDS_PER_SEGMENT 1
#define LEDS_PER_DIGIT 7
#define GRID_WIDTH 13
#define GRID_HEIGHT 5

#define NUMPIXELS 30


RTC_DS3231 rtc;

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int mode = 0;
bool justEnteredMode = true;

double timeOfLastInput = 0;
double timeOfLastRefresh = 0;
int inactivityTimeoutDuration = 10000;

uint32_t startColor,endColor;

uint16_t startHue = 0;
uint16_t endHue = 80;

int brightness = 50;

int inputHours = 1;
int inputMinutes = 0;

int inputColor = 0;
int inputColorShift = 12;
int inputColorDirection = 0;

int analogInput = 0;
bool upIsPressed, rightIsPressed, downIsPressed, leftIsPressed, centerIsPressed = false;
int upHeldCycles, rightHeldCycles, downHeldCycles, leftHeldCycles, centerHeldCycles = 0;

// Defines the light number for each light by its position in a grid covering the whole clock face
// 0 indicates positions where no light exists

 const int PROGMEM pixelNumber[5][13] = 
{
  {0,2,0,   0, 9, 0,    0,   0,18, 0,   0,25,0},
  {1,0,3,   8, 0,10,   15,   17,0,19,   24,0,26},
  {0,7,0,   0,14, 0,    0,   0,23, 0,   0,30,0},
  {6,0,4,   13,0,11,   16,   22,0,20,   29,0,27},
  {0,5,0,   0,12, 0,    0,   0,21, 0,   0,28,0},
};

const int pixelValues[][7] = 
{
  {1,1,1,1,1,1,0}, // Number 0
  {0,0,1,1,0,0,0}, // Number 1
  {0,1,1,0,1,1,1}, // Number 2
  {0,1,1,1,1,0,1}, // Number 3
  {1,0,1,1,0,0,1}, // Number 4
  {1,1,0,1,1,0,1}, // Number 5
  {1,1,0,1,1,1,1}, // Number 6
  {0,1,1,1,0,0,0}, // Number 7
  {1,1,1,1,1,1,1}, // Number 8
  {1,1,1,1,1,0,1}, // Number 9
  {0,0,0,0,0,0,0}  // Digit off
};


void setup () 
{
  Serial.begin(9600);

  if (! rtc.begin()) 
  {
    Serial.println("Couldn't find RTC");
    while (1);
  }
    
  if (rtc.lostPower()) 
  {
    Serial.println("RTC lost power, lets set the time!");
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }

  // Uncomment below to set time to compile time.
  // THIS WILL KEEP RESETTING THE TIME EVERY BOOT UNTIL CODE WITH THIS DISABLED IS UPLOADED
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  strip.begin(); // This initializes the NeoPixel library.

  pinMode(A2, INPUT);
  pinMode(13,OUTPUT);
  digitalWrite(13, HIGH);
   pinMode(12,OUTPUT);
  digitalWrite(12, LOW);
}

void loop () 
{
  analogInput = analogRead(A2);
   Serial.println(analogInput);
   delay(100);

  if (upIsPressed){
    upHeldCycles++;
  }
  else{
    upHeldCycles = 0;}
    
  if (rightIsPressed){
    rightHeldCycles++;}
  else{
    rightHeldCycles = 0;}
    
  if (downIsPressed){
    downHeldCycles++;}
  else{
    downHeldCycles = 0;}
    
  if (leftIsPressed){
    leftHeldCycles++;}
  else{
    leftHeldCycles = 0;}

  if (centerIsPressed){
    centerHeldCycles++;}
  else{
    centerHeldCycles = 0;}
  

  upIsPressed = rightIsPressed = downIsPressed = leftIsPressed = centerIsPressed = false;

  
  // Set isPressedValues
  if (analogInput > 130 && analogInput < 190)
  {
      upIsPressed = true;
      timeOfLastInput = millis();
      Serial.print("up ");
      Serial.println(upHeldCycles);
  }
  else if (analogInput > 190 && analogInput < 220)
  {
      rightIsPressed = true;
      timeOfLastInput = millis();
      Serial.print("right ");
      Serial.println(rightHeldCycles);
  }
  else if (analogInput > 230 && analogInput < 270)
  {
      downIsPressed = true;
      timeOfLastInput = millis();
      Serial.print("down ");
      Serial.println(downHeldCycles);
  }
  else if (analogInput > 280 && analogInput < 370)
  {
      leftIsPressed = true;
      timeOfLastInput = millis();
      Serial.print("left ");
      Serial.println(leftHeldCycles);
  }
  else if (analogInput > 380 && analogInput < 600)
  {
      centerIsPressed = true;
      timeOfLastInput = millis();
      Serial.print("center ");
      Serial.println(centerHeldCycles);
  }

  
  if (leftHeldCycles == 1)
  {
    mode--;
    justEnteredMode = true;
  }

  if (rightHeldCycles == 1) 
  {
    mode++;
    justEnteredMode = true;
  }

  int delayNum = 500;

  DateTime now = rtc.now();
  

  int convertedHour;

  if (now.hour() > 12) 
  {
    convertedHour = now.hour() - 12;
  }
  else 
  {
    convertedHour = now.hour();
  }

  int num0 = (convertedHour /10) % 10;
  int num1 = convertedHour % 10;
  int num2 = (now.minute() /10) % 10;
  int num3 = now.minute() % 10;

  // Time display and brightness adjust mode
  if (mode == 0) 
  {
    // Run only on first instance of loop
    if (justEnteredMode == true) 
    {
      Serial.println("Mode 0, display time");
      Serial.print(num0);
      Serial.print(num1);
      Serial.print(":");
      Serial.print(num2);
      Serial.println(num3);
    }
    justEnteredMode = false;

    if (upIsPressed)
    {
      adjustVariable(&brightness, 1, 1, 100);
      Serial.print("Brightness raised to ");
      Serial.println(brightness);
    }
    
    if (downIsPressed)
    {
      adjustVariable(&brightness, -1, 1, 100);
      Serial.print("Brightness lowered to ");
      Serial.println(brightness);
    }

    updateDigits(num0,num1,num2,num3);

    inputColor += 5;
  }

  // Color set mode
  else if (mode == 1) 
  {
    // Run only on first instance of loop
    if (justEnteredMode == true) 
    {
      Serial.println("Mode 1, set color 1");
      updateDigits(1, 10, 10, 10);
      delay(300);
    }
    
    justEnteredMode = false;

    if (upIsPressed)
    {
      adjustVariable(&inputColor, -5, 0, 360);
      Serial.print("Input color raised to ");
      Serial.println(inputColor);
    }
    
    if (downIsPressed)
    {
      adjustVariable(&inputColor, 5, 0, 360);
      Serial.print("Input color lowered to ");
      Serial.println(inputColor);
    }
    
    resetModeAfterInactivity();

    updateDigits(8, 8, 8, 8);
  }

  
  // Color shift amount set mode
  else if (mode == 2) 
  {
    // Run only on first instance of loop
    if (justEnteredMode == true) 
    {
      Serial.println("Mode 2, set color shift amount");
      updateDigits(2, 10, 10, 10);
      delay(300);
    }
    justEnteredMode = false;

    if (upIsPressed)
    {
      adjustVariable(&inputColorShift, -1, -30, 30);
      Serial.print("Color shift amount raised to ");
      Serial.println(inputColorShift);
    }
    
    if (downIsPressed)
    {
      adjustVariable(&inputColorShift, 1, -30, 30);
      Serial.print("Color shift amount lowered to ");
      Serial.println(inputColorShift);
    }
    
    resetModeAfterInactivity();
        
    updateDigits(8, 8, 8, 8);
  }  

  
  // Gradient direction set mode
  else if (mode == 3) 
  {
    // Run only on first instance of loop
    if (justEnteredMode == true) 
    {
      Serial.println("Mode 3, set gradient direction");
      updateDigits(3, 10, 10, 10);
      delay(300);
    }
    justEnteredMode = false;

    if (upIsPressed)
    {
      adjustVariable(&inputColorDirection, -1, 0, 2);
      Serial.print("Input color direction set to ");
      Serial.println(inputColorDirection);
    }
    
    if (downIsPressed)
    {
      adjustVariable(&inputColorDirection, 1, 0, 2);
      Serial.print("Input color direction set to ");
      Serial.println(inputColorDirection);
    }

    resetModeAfterInactivity();

    updateDigits(8, 8, 8, 8);
  }


  // Hour set mode
  else if (mode == 4) 
  {
    // Run only on first instance of loop
    if (justEnteredMode == true) 
    {
      Serial.println("Mode 4, set hour");
    }
    justEnteredMode = false;

    if (upIsPressed)
    {
      adjustVariable(&inputHours, 1, 1, 12);
      Serial.print("Hours raised to ");
      Serial.println(inputHours);
    }
    
    if (downIsPressed)
    {
      adjustVariable(&inputHours, -1, 1, 12);
      Serial.print("Hours lowered to ");
      Serial.println(inputHours);
    }    

    int digitOne = (millis() % 1000 < 800) ? (inputHours / 10) % 10 : 10;
    int digitTwo = (millis() % 1000 < 800) ? inputHours % 10 : 10;
    
    resetModeAfterInactivity();

    updateDigits(digitOne, digitTwo, num2, num3);

    rtc.adjust(DateTime(now.year(), now.month(), now.day(), inputHours, now.minute(), 0));
  }

  // Minute set mode
  else if (mode == 5) 
  {
    inputMinutes = now.minute();
    
    // Run only on first instance of loop
    if (justEnteredMode == true) 
    {
      Serial.println("Mode 6, set minutes");
    }
    justEnteredMode = false;

    if (upIsPressed)
    {
      adjustVariable(&inputMinutes, 1, 0, 59);
      Serial.print("Minutes raised to ");
      Serial.println(inputMinutes);
    }
    
    if (downIsPressed)
    {
      adjustVariable(&inputMinutes, -1, 0, 59);
      Serial.print("Minutes lowered to ");
      Serial.println(inputMinutes);
    }        
    
    resetModeAfterInactivity();

    int digitThree = (millis() % 1000 < 800) ? floor(inputMinutes/10) : 10;
    int digitFour = (millis() % 1000 < 800) ? (inputMinutes % 10) : 10;

    //int digitThree = floor(inputMinutes / 10);
    //int digitFour = inputMinutes % 10;
    
    updateDigits(num0, num1, digitThree, digitFour);

    rtc.adjust(DateTime(now.year(), now.month(), now.day(), now.hour(), inputMinutes, 0));
  }
  
  else 
  {
    mode = 0;
  }
  
}


void resetModeAfterInactivity() 
{
  if (timeOfLastInput + inactivityTimeoutDuration < millis()) 
  {
    Serial.print("Time of last input: ");
    Serial.print(timeOfLastInput);
    Serial.print(". Current milis: ");
    Serial.println(millis());
    mode = 0;
  }
}

void updateDigits(int num0, int num1, int num2, int num3) 
{
  if (timeOfLastRefresh + 100 < millis()) 
  {
    timeOfLastRefresh = millis();
    
    // Set the segments
    for (int v=0; v<GRID_HEIGHT; v++) 
    {
      for (int h=0; h<GRID_WIDTH; h++) 
      {
        // Subtract one from the value we retrieve because
        // we're starting at 1 in the array
        // but at 0 on strip.setPixelColor
        int currentPixelNumber = pgm_read_word_near(&(pixelNumber[v][h])) - 1;
    
        if (currentPixelNumber >= 0) 
        {
          // There is a pixel here, see if it should be lit
          int digitOffset = 0;
  
          // Track which number we want to draw to the current digit position
          int numberToDraw;
  
          // Track if we're on a divider pixel
          bool divider = false;
          
          // First digit
          if (h >= 0 && h < LEDS_PER_SEGMENT + 2) 
          {
            digitOffset = 0;
            numberToDraw = num0;
            if (numberToDraw == 0) 
            {
              numberToDraw = 10;
            }
          }
  
          // Second digit
          if (h >=LEDS_PER_SEGMENT + 2 && h < (LEDS_PER_SEGMENT * 2) + 4) 
          {
            digitOffset = LEDS_PER_SEGMENT * SEGMENTS_PER_DIGIT;
            numberToDraw = num1;
          }
  
          // Divider
          if (h == (LEDS_PER_SEGMENT * 2) + 4) 
          {
            digitOffset = (LEDS_PER_SEGMENT * SEGMENTS_PER_DIGIT) * 2;
            divider = true;
          }
  
          if (h >= (LEDS_PER_SEGMENT * 2) + 5 && h <= (LEDS_PER_SEGMENT * 3) + 6) 
          {
            digitOffset = (LEDS_PER_SEGMENT * SEGMENTS_PER_DIGIT) * 2 + 2;
            numberToDraw = num2;
          }
  
          if (h >= (LEDS_PER_SEGMENT * 3) + 7 && h <= (LEDS_PER_SEGMENT * 4) + 8) 
          {
            digitOffset = (LEDS_PER_SEGMENT * SEGMENTS_PER_DIGIT) * 3 + 2;
            numberToDraw = num3;
          }
          
          if (pixelValues[numberToDraw][currentPixelNumber-digitOffset] == 1 || divider == true) 
          {   
            if (inputColorDirection == 0) 
            {
              uint32_t color = HSV_to_RGB(inputColor + h*inputColorShift,100,brightness);
              strip.setPixelColor(currentPixelNumber, color); 
            }
            else if (inputColorDirection == 1) 
            {
              uint32_t color = HSV_to_RGB(inputColor + v*inputColorShift,100,brightness);
              strip.setPixelColor(currentPixelNumber, color); 
            }
            else 
            {
              uint32_t color = HSV_to_RGB(inputColor,100,brightness);
              strip.setPixelColor(currentPixelNumber, color); 
            }
          }
          else 
          {
            uint32_t color = strip.Color(0,0,0);
            strip.setPixelColor(currentPixelNumber, color);
          }
          
          strip.show();
        }
      }
  
    }
  
  }
    
}


void adjustVariable(int *variable, int change, int minNum, int maxNum) 
{
  *variable += change;
    
  if (*variable < minNum) 
    *variable = maxNum;

  if (*variable > maxNum)
    *variable = minNum;
}


uint32_t HSV_to_RGB(float h, float s, float v) 
{
  int i;
  float f,p,q,t;
  uint8_t r,g,b;

  while (h >= 360) 
  {
    h = h - 360;
  }
  while (h < 0) 
  {
    h = h + 360;
  }
  
  h = max(0.0, min(360.0, h));
  s = max(0.0, min(100.0, s));
  v = max(0.0, min(100.0, v));
  
  s /= 100;
  v /= 100;
  
  if (s == 0) 
  {
    // Achromatic (grey)
    r = g = b = round(v*255);
    return;
  }

  h /= 60; // sector 0 to 5
  i = floor(h);
  f = h - i; // factorial part of h
  p = v * (1 - s);
  q = v * (1 - s * f);
  t = v * (1 - s * (1 - f));
    
  switch(i)
  {
    case 0:
      r = round(255*v);
      g = round(255*t);
      b = round(255*p);
      break;
    case 1:
      r = round(255*q);
      g = round(255*v);
      b = round(255*p);
      break;
    case 2:
      r = round(255*p);
      g = round(255*v);
      b = round(255*t);
      break;
    case 3:
      r = round(255*p);
      g = round(255*q);
      b = round(255*v);
      break;
    case 4:
      r = round(255*t);
      g = round(255*p);
      b = round(255*v);
      break;
    default: // case 5:
      r = round(255*v);
      g = round(255*p);
      b = round(255*q);
  }

  return strip.Color(r,g,b);  
};

Amazing Light Effects Using Hot Glue Stick And RGB LED

Hello friends, this is amazing project using RGB LED. This amazing project will give you many colorful light effect for your room. This is very simple to make.

Diagram:

Componants :

Arduino Nano : https://amzn.to/37Qhz0e
WS2811 LED Chain : https://amzn.to/3kCFXWy
MT3608 Module : https://amzn.to/3uyHfXC
DC Socket : https://amzn.to/2HLNYtS

Code :

#include <FastLED.h>

FASTLED_USING_NAMESPACE



#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
#warning "Requires FastLED 3.1 or later; check github for latest code."
#endif

#define DATA_PIN    6
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
#define NUM_LEDS    24

#define UPDATES_PER_SECOND 100
CRGB leds[NUM_LEDS];


#define BRIGHTNESS          255
#define FRAMES_PER_SECOND  120
#define COOLING  55
#define SPARKING 120



bool gReverseDirection = false;
CRGBPalette16 gPal;


CRGBPalette16 pacifica_palette_1 = 
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117, 
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x14554B, 0x28AA50 };
CRGBPalette16 pacifica_palette_2 = 
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117, 
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x0C5F52, 0x19BE5F };
CRGBPalette16 pacifica_palette_3 = 
    { 0x000208, 0x00030E, 0x000514, 0x00061A, 0x000820, 0x000927, 0x000B2D, 0x000C33, 
      0x000E39, 0x001040, 0x001450, 0x001860, 0x001C70, 0x002080, 0x1040BF, 0x2060FF };


CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
      
void setup() {
  delay(3000); // 3 second delay for recovery
  
  // tell FastLED about the LED strip configuration
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
   
  //FastLED.addLeds<LED_TYPE,DATA_PIN,CLK_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);

  // set master brightness control
  FastLED.setBrightness(BRIGHTNESS);
}


// List of patterns to cycle through.  Each is defined as a separate function below.
typedef void (*SimplePatternList[])();
SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm,Fire2012,first_light,second_light,cylon,pacifica_loop,rgbsetdemo };
//SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm,Fire2012,Fire2012WithPalette,first_light,second_light,cylon,pacifica_loop,rgbsetdemo,colorpalete };
//SimplePatternList gPatterns = { colorpalete };
uint8_t gCurrentPatternNumber = 0; // Index number of which pattern is current
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
  
void loop()
{
  // Call the current pattern function once, updating the 'leds' array
  gPatterns[gCurrentPatternNumber]();

  // send the 'leds' array out to the actual LED strip
  FastLED.show();  
  // insert a delay to keep the framerate modest
  FastLED.delay(1000/FRAMES_PER_SECOND); 

  // do some periodic updates
  EVERY_N_MILLISECONDS( 20 ) { gHue++; } // slowly cycle the "base color" through the rainbow
  EVERY_N_SECONDS( 20 ) { nextPattern(); } // change patterns periodically
}

#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))

void nextPattern()
{
  // add one to the current pattern number, and wrap around at the end
  gCurrentPatternNumber = (gCurrentPatternNumber + 1) % ARRAY_SIZE( gPatterns);
}

void rainbow() 
{
  // FastLED's built-in rainbow generator
  fill_rainbow( leds, NUM_LEDS, gHue, 7);
}

void rainbowWithGlitter() 
{
  // built-in FastLED rainbow, plus some random sparkly glitter
  rainbow();
  addGlitter(80);
}

void addGlitter( fract8 chanceOfGlitter) 
{
  if( random8() < chanceOfGlitter) {
    leds[ random16(NUM_LEDS) ] += CRGB::White;
  }
}

void confetti() 
{
  // random colored speckles that blink in and fade smoothly
  fadeToBlackBy( leds, NUM_LEDS, 10);
  int pos = random16(NUM_LEDS);
  leds[pos] += CHSV( gHue + random8(64), 200, 255);
}

void sinelon()
{
  // a colored dot sweeping back and forth, with fading trails
  fadeToBlackBy( leds, NUM_LEDS, 20);
  int pos = beatsin16( 13, 0, NUM_LEDS-1 );
  leds[pos] += CHSV( gHue, 255, 192);
}

void bpm()
{
  // colored stripes pulsing at a defined Beats-Per-Minute (BPM)
  uint8_t BeatsPerMinute = 62;
  CRGBPalette16 palette = PartyColors_p;
  uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
  for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

void 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-1 )] |= CHSV(dothue, 200, 255);
    dothue += 32;
  }
}

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;
    }
}

void first_light(){
  static uint8_t hue = 0;
   for(int whiteLed = 0; whiteLed < NUM_LEDS; whiteLed = whiteLed + 1) {
      // Turn our current led on to white, then show the leds
      leds[whiteLed] =  CHSV(hue++, 255, 255);

      // Show the leds (only one of which is set to white, from above)
      FastLED.show();

      // Wait a little bit
      delay(1);

      // Turn our current led back to black for the next loop around
      leds[whiteLed] = leds[whiteLed] = CRGB::Black;
   }
}
void second_light(){
  static uint8_t hue = 0;
   for(int whiteLed = 0; whiteLed < NUM_LEDS; whiteLed = whiteLed + 1) {
      // Turn our current led on to white, then show the leds
      leds[whiteLed] =  CHSV(hue++, 255, 255);

      // Show the leds (only one of which is set to white, from above)
      FastLED.show();

      // Wait a little bit
      delay(1);

      // Turn our current led back to black for the next loop around
      leds[whiteLed] = CHSV(hue++, 255, 255);
   }
}
void cylon(){
    static uint8_t hue = 0;
 // Serial.print("x");
  // First slide the led in one direction
  for(int i = 0; i < NUM_LEDS; i++) {
    // Set the i'th led to red 
    leds[i] = CHSV(hue++, 255, 255);
    // Show the leds
    FastLED.show(); 
    // now that we've shown the leds, reset the i'th led to black
    // leds[i] = CRGB::Black;
    fadeall();
    // Wait a little bit before we loop around and do it again
    delay(5);
  }
  //Serial.print("x");

  // Now go in the other direction.  
  for(int i = (NUM_LEDS)-1; i >= 0; i--) {
    // Set the i'th led to red 
    leds[i] = CHSV(hue++, 255, 255);
    // Show the leds
    FastLED.show();
    // now that we've shown the leds, reset the i'th led to black
    // leds[i] = CRGB::Black;
    fadeall();
    // Wait a little bit before we loop around and do it again
    delay(5);
  }
}
void fadeall() { for(int i = 0; i < NUM_LEDS; i++) { leds[i].nscale8(250); } }

void Fire2012WithPalette()
{
// 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++) {
      // Scale the heat value from 0-255 down to 0-240
      // for best results with color palettes.
      byte colorindex = scale8( heat[j], 240);
      CRGB color = ColorFromPalette( gPal, colorindex);
      int pixelnumber;
      if( gReverseDirection ) {
        pixelnumber = (NUM_LEDS-1) - j;
      } else {
        pixelnumber = j;
      }
      leds[pixelnumber] = color;
    }
}
void rgbsetdemo(){
 CRGBArray<NUM_LEDS> leds;
  FastLED.addLeds<NEOPIXEL,6>(leds, NUM_LEDS);
  static uint8_t hue;
  for(int i = 0; i < NUM_LEDS/2; i++) {   
    // fade everything out
    leds.fadeToBlackBy(20);

    // let's set an led value
    leds[i] = CHSV(hue++,255,255);

    // now, let's first 20 leds to the top 20 leds, 
    leds(NUM_LEDS/2,NUM_LEDS-1) = leds(NUM_LEDS/2 - 1 ,0);
    FastLED.delay(13);
  }
  
}

void pacifica_loop()
{
  // Increment the four "color index start" counters, one for each wave layer.
  // Each is incremented at a different speed, and the speeds vary over time.
  static uint16_t sCIStart1, sCIStart2, sCIStart3, sCIStart4;
  static uint32_t sLastms = 0;
  uint32_t ms = GET_MILLIS();
  uint32_t deltams = ms - sLastms;
  sLastms = ms;
  uint16_t speedfactor1 = beatsin16(3, 179, 269);
  uint16_t speedfactor2 = beatsin16(4, 179, 269);
  uint32_t deltams1 = (deltams * speedfactor1) / 256;
  uint32_t deltams2 = (deltams * speedfactor2) / 256;
  uint32_t deltams21 = (deltams1 + deltams2) / 2;
  sCIStart1 += (deltams1 * beatsin88(1011,10,13));
  sCIStart2 -= (deltams21 * beatsin88(777,8,11));
  sCIStart3 -= (deltams1 * beatsin88(501,5,7));
  sCIStart4 -= (deltams2 * beatsin88(257,4,6));

  // Clear out the LED array to a dim background blue-green
  fill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));

  // Render each of four layers, with different scales and speeds, that vary over time
  pacifica_one_layer( pacifica_palette_1, sCIStart1, beatsin16( 3, 11 * 256, 14 * 256), beatsin8( 10, 70, 130), 0-beat16( 301) );
  pacifica_one_layer( pacifica_palette_2, sCIStart2, beatsin16( 4,  6 * 256,  9 * 256), beatsin8( 17, 40,  80), beat16( 401) );
  pacifica_one_layer( pacifica_palette_3, sCIStart3, 6 * 256, beatsin8( 9, 10,38), 0-beat16(503));
  pacifica_one_layer( pacifica_palette_3, sCIStart4, 5 * 256, beatsin8( 8, 10,28), beat16(601));

  // Add brighter 'whitecaps' where the waves lines up more
  pacifica_add_whitecaps();

  // Deepen the blues and greens a bit
  pacifica_deepen_colors();
}

// Add one layer of waves into the led array
void pacifica_one_layer( CRGBPalette16& p, uint16_t cistart, uint16_t wavescale, uint8_t bri, uint16_t ioff)
{
  uint16_t ci = cistart;
  uint16_t waveangle = ioff;
  uint16_t wavescale_half = (wavescale / 2) + 20;
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    waveangle += 250;
    uint16_t s16 = sin16( waveangle ) + 32768;
    uint16_t cs = scale16( s16 , wavescale_half ) + wavescale_half;
    ci += cs;
    uint16_t sindex16 = sin16( ci) + 32768;
    uint8_t sindex8 = scale16( sindex16, 240);
    CRGB c = ColorFromPalette( p, sindex8, bri, LINEARBLEND);
    leds[i] += c;
  }
}

// Add extra 'white' to areas where the four layers of light have lined up brightly
void pacifica_add_whitecaps()
{
  uint8_t basethreshold = beatsin8( 9, 55, 65);
  uint8_t wave = beat8( 7 );
  
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    uint8_t threshold = scale8( sin8( wave), 20) + basethreshold;
    wave += 7;
    uint8_t l = leds[i].getAverageLight();
    if( l > threshold) {
      uint8_t overage = l - threshold;
      uint8_t overage2 = qadd8( overage, overage);
      leds[i] += CRGB( overage, overage2, qadd8( overage2, overage2));
    }
  }
}

// Deepen the blues and greens
void pacifica_deepen_colors()
{
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    leds[i].blue = scale8( leds[i].blue,  145); 
    leds[i].green= scale8( leds[i].green, 200); 
    leds[i] |= CRGB( 2, 5, 7);
  }
}

void colorpalete(){
   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 = 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
};



// Additional notes on FastLED compact palettes:
//
// Normally, in computer graphics, the palette (or "color lookup table")
// has 256 entries, each containing a specific 24-bit RGB color.  You can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly "too many" bytes.
//
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
//
// However, FastLED also offers a compact alternative.  FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate palette
// entries between each pair.
//
// So for example, if you set the first two explicit entries of a compact 
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved 
// the first sixteen entries from the virtual palette (of 256), you'd get
// Green, followed by a smooth gradient from green-to-blue, and then Blue.

How to make Christmas RGB LED tree

This is my new project of this Christmas festival. This is a small RGB LED Christmas tree for your room and table. This tree will give you multiple color and light effects. This is very easy to make, if you want to make this, just follow all the step and make your own RGB Christmas tree.

Materials:

1. ESP32 Module : https://amzn.to/37Qhz0e
2. WS2812B LED Strip :https://amzn.to/3r2hwFB
3. DC Socket : https://amzn.to/2HLNYtS
4. SPST Switch : https://amzn.to/3ahntIX
5. Sun Board : You will get on glass shop
6. 40mm PVC pipe : You will get on hardware shop
7. 5V 5Amp power supply : https://amzn.to/2LIwu3q

Diagram :

Code :

How To Make 5×10 LED RGB Chakri Using RGB LED

Hello friends, This is very cool and amazing light effects using pixel LED. You can make this in Diwali. Simply this project made using cycle ring and pixel LED. Just follow all the step and make your own amazing light effect for Diwali.

Components :

1. Arduino Nano : https://amzn.to/37Qhz0e
2. WS2812B LED Strip : https://amzn.to/3kCFXWy
3. DC Socket : https://amzn.to/2HLNYtS

Code:

Amazing Idea Using RGB LED and Smartphone

Hello friends, In this video you learn how to make RGB light control using RGB WS2812B LED. Color completely control from smartphone using Bluetooth. This is very easy to make. Its connection is very simple. Follow all the step and make your own amazing light effect for you room.

Diagram:

Code:

#include <SoftwareSerial.h>
#include "Arduino.h"
#include <Wire.h>//Include libraries: SoftwareSerial & Wire
SoftwareSerial ESP_BT(0,1); //Define PIN11 & PIN12 as RX and TX pins
#include <Adafruit_NeoPixel.h>
#define PIN 3
// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(23, PIN, NEO_GRB + NEO_KHZ800);
// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
// and minimize distance between Arduino and first pixel.  Avoid connecting
// on a live circuit...if you must, connect GND first.
boolean RGB_Completed = false;
String RGB2 ,RGB1="255.255.255";
int red=125, green=125, blue=125, starting=0;
int p=0,brt=200;
void setup() {
Serial.begin(115200);
  ESP_BT.begin(9600);//#define BAUDRATE 38400
  strip.begin();
  strip.setBrightness(255);
 // colorwipemain();
  strip.show(); // Initialize all pixels to 'off'
}
void loop() {
   while(ESP_BT.available()){
    delay(20);
    char ReadChar = (char)ESP_BT.read();
     Serial.println(ReadChar);
 
       if(ReadChar == ')'){
        // RGB_Completed = true;
         break;
        
     }else{
        RGB2+= ReadChar;
        
            }
   }
   
      if(RGB2.length()>0){
        RGB1="";
        RGB1=RGB2;
        Serial.println(RGB1);
        rgbcal();
       RGB2="";
      }
   if(starting==0){
    rgbcal();
    starting=1;
    }
}
void rgbcal(){
     
  int SP1 = RGB1.indexOf('.');
  int SP2 = RGB1.indexOf('.', SP1+1);
  int SP3 = RGB1.indexOf('.', SP2+1);
  int R = RGB1.substring(0, SP1).toInt();
  int G = RGB1.substring(SP1+1, SP2).toInt();
  int B = RGB1.substring(SP2+1, SP3).toInt();
   for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
    strip.setPixelColor(i, strip.Color(R,G,B));         //  Set pixel's color (in RAM)
    if(!ESP_BT.available()){
    strip.show(); 
    }else{
      break;
    }
   }

#include <SoftwareSerial.h>
#include "Arduino.h"
#include <Wire.h>//Include libraries: SoftwareSerial & Wire
SoftwareSerial ESP_BT(0,1); //Define PIN11 & PIN12 as RX and TX pins
#include <Adafruit_NeoPixel.h>
#define PIN 3
// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(23, PIN, NEO_GRB + NEO_KHZ800);
// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
// and minimize distance between Arduino and first pixel.  Avoid connecting
// on a live circuit...if you must, connect GND first.
boolean RGB_Completed = false;
String RGB2 ,RGB1="255.255.255";
int red=125, green=125, blue=125, starting=0;
int p=0,brt=200;
void setup() {
Serial.begin(115200);
  ESP_BT.begin(9600);//#define BAUDRATE 38400
  strip.begin();
  strip.setBrightness(255);
 // colorwipemain();
  strip.show(); // Initialize all pixels to 'off'
}
void loop() {
   while(ESP_BT.available()){
    delay(20);
    char ReadChar = (char)ESP_BT.read();
     Serial.println(ReadChar);
 
       if(ReadChar == ')'){
        // RGB_Completed = true;
         break;
        
     }else{
        RGB2+= ReadChar;
        
            }
   }
   
      if(RGB2.length()>0){
        RGB1="";
        RGB1=RGB2;
        Serial.println(RGB1);
        rgbcal();
       RGB2="";
      }
   if(starting==0){
    rgbcal();
    starting=1;
    }
}
void rgbcal(){
     
  int SP1 = RGB1.indexOf('.');
  int SP2 = RGB1.indexOf('.', SP1+1);
  int SP3 = RGB1.indexOf('.', SP2+1);
  int R = RGB1.substring(0, SP1).toInt();
  int G = RGB1.substring(SP1+1, SP2).toInt();
  int B = RGB1.substring(SP2+1, SP3).toInt();
   for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
    strip.setPixelColor(i, strip.Color(R,G,B));         //  Set pixel's color (in RAM)
    if(!ESP_BT.available()){
    strip.show(); 
    }else{
      break;
    }
   }

Amazing Light Effect Using RGB Light and Glue Stick

An interesting light display using 16 glue sticks and 32 WS2812B RGB LED strips.This lamp was based on a similar lamp called Hot Glue LED Matrix Lamp. the goal was to replace the 12mm Diffused Digital RGB LED used in jbumstead’s design with cheap WS2812B RGB strips and to make the container for the LEDs.

Components List:

1. WS2812B LED Strip: https://amzn.to/3j0Tbv5
2. Glue Sticks : https://amzn.to/35Z1XoB
3. Plastic Box : You will get from local electronics shop
4. 10K Pot : https://amzn.to/2TIAGke
5. Mini Push Switch : https://amzn.to/34NklkC
6. Arduino Nano : https://amzn.to/35Z2rep
7. SPST Switch : https://amzn.to/3ef0kqu

Connection Diagram :

Code:

Main Page:

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#include "Button.h"

#define PIN_LED 2
#define PIN_SWITCH 3
#define PIN_POT A0

#define LEDS 32

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN_LED, NEO_GRB + NEO_KHZ800);
Button mode = Button(PIN_SWITCH);
bool modePressed = false;

//Physical LED map for bottom and top LED arrays

const uint8_t botLED[] PROGMEM = {
  16,9,8,1,
  15,10,7,2,
  14,11,6,3,
  13,12,5,4,

};

const uint8_t topLED[] PROGMEM = {
  17,24,25,32,
  18,23,26,31,
  19,22,27,30,
  20,21,28,29,
};

//Storage for current values
int red = 128;
int green = 128;
int blue = 128;
int pattern = 1;

// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
// and minimize distance between Arduino and first pixel.  Avoid connecting
// on a live circuit...if you must, connect GND first.

void setup() 
{
  Serial.begin(115200);

  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_SWITCH, INPUT);
  pinMode(PIN_POT, INPUT);
  
  //Pixel Strip
  Serial.println("Setup()");
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'

  //Button callbacks
  //mode.Background(ButtonBackground);

  //Set ISR for pin change on MODE pin
  Button::PinChangeSetup(PIN_SWITCH);
}

void loop() 
{
  if (modePressed)
  {
    pattern = (pattern % 8) + 1; 
    strip.clear();
  }
  modePressed = false;
  Serial.print("Mode ");
  Serial.print(pattern, DEC);
  Serial.println();
  switch (pattern)
  {
    case 1: colorWipe(strip.Color(255, 0, 0)); break; // Red
    case 2: colorWipe(strip.Color(0, 255, 0)); break; // Green
    case 3: colorWipe(strip.Color(0, 0, 255)); break; // Blue
    case 4: theaterChase(strip.Color(127, 127, 127)); break; // White
    case 5: rainbow(); break;
    case 6: rainbowDifference(); break;
    case 7: rainbowCycle(); break;
    case 8: rainbowCycleDifference(); break;
    case 9: theaterChaseRainbow(); break;
  }
  if (!modePressed)
  {
    modePressed = mode.Pressed();
  }
}

//Mode button interrupt to break out of loops etc
//PCINT1 handles pin changes for pins for A0 to A5
ISR (PCINT2_vect)
{
  modePressed = modePressed | (mode.State() == LOW);
}

void ButtonBackground(void)
{
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c) 
{
  int total = strip.numPixels() / 2;
  for(uint16_t i=0; i < total && !modePressed; i++) 
  {
    uint8_t botIndex = pgm_read_byte(&botLED[i]) - 1;
    strip.setPixelColor(botIndex, c);
    uint8_t topIndex = pgm_read_byte(&topLED[i]) - 1;
    strip.setPixelColor(topIndex, c);
    strip.show();
    delay(map(analogRead(PIN_POT), 0, 1024, 100, 0));
  }
  for(uint16_t i=total; i > 0 && !modePressed; i--) 
  {
    uint8_t botIndex = pgm_read_byte(&botLED[i]) - 1;
    strip.setPixelColor(botIndex, 0);
    uint8_t topIndex = pgm_read_byte(&topLED[i]) - 1;
    strip.setPixelColor(topIndex, 0);
    strip.show();
    delay(map(analogRead(PIN_POT), 0, 1024, 100, 0));
  }
}

void rainbow() 
{
  int total = strip.numPixels() / 2;
  for(uint16_t j=0; j < 256 && !modePressed; j++) 
  {
    for(uint16_t i=0; i < total && !modePressed; i++) 
    {
      uint32_t c = Wheel((i+j) & 255);
      uint8_t botIndex = pgm_read_byte(&botLED[i]) - 1;
      strip.setPixelColor(botIndex, c);
      uint8_t topIndex = pgm_read_byte(&topLED[i]) - 1;
      strip.setPixelColor(topIndex, c);
    }
    strip.show();
    delay(map(analogRead(PIN_POT), 0, 1024, 40, 0));
  }
}

void rainbowDifference() 
{
  int total = strip.numPixels() / 2;
  for(uint16_t j=0; j < 256 && !modePressed; j++) 
  {
    for(uint16_t i=0; i < total && !modePressed; i++) 
    {
      uint32_t c = Wheel((i+j) & 255);
      uint8_t botIndex = pgm_read_byte(&botLED[i]) - 1;
      strip.setPixelColor(botIndex, c);
      c = Wheel((i+j+64) & 255);
      uint8_t topIndex = pgm_read_byte(&topLED[i]) - 1;
      strip.setPixelColor(topIndex, c);
    }
    strip.show();
    delay(map(analogRead(PIN_POT), 0, 1024, 40, 0));
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle() 
{
  int total = strip.numPixels() / 2;
  for(uint16_t j=0; j < 256*5 && !modePressed; j++) 
  { // 5 cycles of all colors on wheel
    for(uint16_t i=0; i < total && !modePressed; i++) 
    {
      uint32_t c = Wheel(((i * 256 / total) + j) & 255);
      uint8_t botIndex = pgm_read_byte(&botLED[i]) - 1;
      strip.setPixelColor(botIndex, c);
      uint8_t topIndex = pgm_read_byte(&topLED[i]) - 1;
      strip.setPixelColor(topIndex, c);
    }
    strip.show();
    delay(map(analogRead(PIN_POT), 0, 1024, 40, 0));
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycleDifference() 
{
  int total = strip.numPixels() / 2;
  for(uint16_t j=0; j < 256*5 && !modePressed; j++) 
  { // 5 cycles of all colors on wheel
    for(uint16_t i=0; i < total && !modePressed; i++) 
    {
      uint32_t c = Wheel(((i * 256 / total) + j) & 255);
      uint8_t botIndex = pgm_read_byte(&botLED[i]) - 1;
      strip.setPixelColor(botIndex, c);
      c = Wheel(((i * 256 / total) + j + 64) & 255);
      uint8_t topIndex = pgm_read_byte(&topLED[i]) - 1;
      strip.setPixelColor(topIndex, c);
    }
    strip.show();
    delay(map(analogRead(PIN_POT), 0, 1024, 40, 0));
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c) 
{
  int total = strip.numPixels() / 2;
  for (int j=0; j < 10 && !modePressed; j++) 
  {  //do 10 cycles of chasing
    for (int q=0; q < 3 && !modePressed; q++) 
    {
      for (uint16_t i=0; i < total && !modePressed; i=i+3) 
      {
        uint8_t botIndex = pgm_read_byte(&botLED[i+q]) - 1; //turn every third pixel on
        strip.setPixelColor(botIndex, c);
        uint8_t topIndex = pgm_read_byte(&topLED[i+q]) - 1;
        strip.setPixelColor(topIndex, c);
      }
      strip.show();

      delay(map(analogRead(PIN_POT), 0, 1024, 1, 150));

      for (uint16_t i=0; i < total && !modePressed; i=i+3) 
      {
        uint8_t botIndex = pgm_read_byte(&botLED[i+q]) - 1; ////turn every third pixel off
        strip.setPixelColor(botIndex, 0);
        uint8_t topIndex = pgm_read_byte(&topLED[i+q]) - 1;
        strip.setPixelColor(topIndex, 0);
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow() 
{
  int total = strip.numPixels() / 2;
  for (int j=0; j < 256 && !modePressed; j++) 
  {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3 && !modePressed; q++) 
    {
      for (uint16_t i=0; i < total && !modePressed; i=i+3) 
      {
        uint32_t c = Wheel( (i+j) % 255);
        uint8_t botIndex = pgm_read_byte(&botLED[i+q]) - 1; //turn every third pixel on
        strip.setPixelColor(botIndex, c);
        uint8_t topIndex = pgm_read_byte(&topLED[i+q]) - 1;
        strip.setPixelColor(topIndex, c);
      }
      strip.show();

      delay(map(analogRead(PIN_POT), 0, 1024, 1, 150));

      for (uint16_t i=0; i < total && !modePressed; i=i+3) 
      {
        uint8_t botIndex = pgm_read_byte(&botLED[i+q]) - 1; ////turn every third pixel off
        strip.setPixelColor(botIndex, 0);
        uint8_t topIndex = pgm_read_byte(&topLED[i+q]) - 1;
        strip.setPixelColor(topIndex, 0);
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) 
{
  WheelPos = 255 - WheelPos;
  if (WheelPos < 85) 
  {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) 
  {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

Button.h

/*
Class: Button
Author: John Bradnam (jbrad2089@gmail.com)
Purpose: Arduino library to handle buttons
*/
#pragma once
#include "Arduino.h"

#define DEBOUNCE_DELAY 5

//Repeat speed
#define REPEAT_START_SPEED 500
#define REPEAT_INCREASE_SPEED 50
#define REPEAT_MAX_SPEED 50

class Button
{
  public:
    //Simple constructor
    Button(int Pin);
    //Background function called when in a wait or repeat loop
    void Background(void (*pBackgroundFunction)());
    //Repeat function called when button is pressed
    void Repeat(void (*pRepeatFunction)());
    //Test whether button is pressed and released
    //Will call repeat function if one is provided
    bool Pressed();
    //Return button state (HIGH or LOW) - LOW = Pressed
    int State();
    //Pin Change Interrupt Setup
    //ISR (PCINT0_vect) pin change interrupt for D8 to D13 
    //ISR (PCINT1_vect) pin change interrupt for A0 to A5 
    //ISR (PCINT2_vect) pin change interrupt for D0 to D7
    static void PinChangeSetup(byte pin);

  private:
    int _pin;
    void (*_repeatCallback)(void);
    void (*_backgroundCallback)(void);

};

Button.cpp

#include "Button.h"

Button::Button(int pin)
{
  _pin = pin;
  pinMode(_pin, INPUT);
}

//Set function to invoke in a delay or repeat loop
void Button::Background(void (*pBackgroundFunction)())
{
  _backgroundCallback = pBackgroundFunction;
}

//Set function to invoke if repeat system required
void Button::Repeat(void (*pRepeatFunction)())
{
  _repeatCallback = pRepeatFunction;
}

static void Button::PinChangeSetup(byte pin) 
{
  *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin));  // enable pin
  PCIFR  |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
  PCICR  |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group 
}


//Tests if a button is pressed and released
//  returns true if the button was pressed and released
//  if repeat callback supplied, the callback is called while the key is pressed
bool Button::Pressed()
{
  bool pressed = false;
  if (digitalRead(_pin) == LOW)
  {
    unsigned long wait = millis() + DEBOUNCE_DELAY;
    while (millis() < wait)
    {
      if (_backgroundCallback != NULL)
      {
        _backgroundCallback();
      }
    }
    if (digitalRead(_pin) == LOW)
    {
      //Set up for repeat loop
      if (_repeatCallback != NULL)
      {
        _repeatCallback();
      }
      unsigned long speed = REPEAT_START_SPEED;
      unsigned long time = millis() + speed;
      while (digitalRead(_pin) == LOW)
      {
        if (_backgroundCallback != NULL)
        {
          _backgroundCallback();
        }
        if (_repeatCallback != NULL && millis() >= time)
        {
          _repeatCallback();
          unsigned long faster = speed - REPEAT_INCREASE_SPEED;
          if (faster >= REPEAT_MAX_SPEED)
          {
            speed = faster;
          }
          time = millis() + speed;
        }
      }
      pressed = true;
    }
  }
  return pressed;
}

//Return current button state
int Button::State()
{
  return digitalRead(_pin);
}

Amazing Light Effect Using RGB LED (Rainbow Light)

Hello friends, In this video you learn how to make amazing light effects using RGB WS2812B LED. This is very easy to make. Its connection is very simple. Follow all the step and make your own amazing light effect for you room.

Connection diagram:

Code:

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 6

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(144, PIN, NEO_GRB + NEO_KHZ800);

// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
// and minimize distance between Arduino and first pixel.  Avoid connecting
// on a live circuit...if you must, connect GND first.

void setup() {
  // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
  #if defined (__AVR_ATtiny85__)
    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
  #endif
  // End of trinket special code

  strip.begin();
  strip.setBrightness(255);
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Some example procedures showing how to display to the pixels:
  colorWipe(strip.Color(255, 0, 0), 50); // Red
  colorWipe(strip.Color(0, 255, 0), 50); // Green
  colorWipe(strip.Color(0, 0, 255), 50); // Blue
//colorWipe(strip.Color(0, 0, 0, 255), 50); // White RGBW
  // Send a theater pixel chase in...
  theaterChase(strip.Color(127, 127, 127), 50); // White
  theaterChase(strip.Color(127, 0, 0), 50); // Red
  theaterChase(strip.Color(0, 0, 127), 50); // Blue

  rainbow(20);
  rainbowCycle(20);
  theaterChaseRainbow(50);
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3; q++) {
      for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}