Amazing Idea Using Lizol Empty Bottle And RGB LED Strip

1 Oct

Amazing Idea Using Lizol Empty Bottle And RGB LED Strip

Hello Friends, This is cool projects for your home. This RGB LED light gives you multiple color effects in your room. In this projects I used WS2812B LED strip to control all led with single wire. This is very simple to make. Just follow all the step and make your own RGB led light

https://youtu.be/s2_kGjZ4WCI

Diagram :

Components:

1) xl 6019 step up buck converter : https://roboman.in/kkuj
1) XL6009 step up buck converter : https://roboman.in/bmpo
2) Arduino Nano: https://roboman.in/59h4
2) Arduino Nano Type C : https://roboman.in/xkfu
3)Small SPST Switch : https://roboman.in/6e72
4) TP-4056 Module : https://roboman.in/oa0m
5) ws2812B led strip 60led/m : https://roboman.in/qtch
5) ws2812B led strip 30led/m : https://roboman.in/6r9a

Code:

#include <FastLED.h>

FASTLED_USING_NAMESPACE

// FastLED "100-lines-of-code" demo reel, showing just a few 
// of the kinds of animation patterns you can quickly and easily 
// compose using FastLED.  
//
// This example also shows one easy way to define multiple 
// animations patterns and have them automatically rotate.
//
// -Mark Kriegsman, December 2014

#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    WS2812
#define COLOR_ORDER GRB
#define NUM_LEDS    60

#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 = { FillLEDsFromPaletteColors };
SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm,Fire2012,first_light,second_light,cylon,pacifica_loop,rgbsetdemo,colorpalete };
//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.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

#include <FastLED.h>

FASTLED_USING_NAMESPACE

// FastLED "100-lines-of-code" demo reel, showing just a few

// of the kinds of animation patterns you can quickly and easily

// compose using FastLED.

// This example also shows one easy way to define multiple

// animations patterns and have them automatically rotate.

// -Mark Kriegsman, December 2014

#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 WS2812

#define COLOR_ORDER GRB

#define NUM_LEDS 60

#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 = { FillLEDsFromPaletteColors };

SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm,Fire2012,first_light,second_light,cylon,pacifica_loop,rgbsetdemo,colorpalete };

//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::Gray,

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.

Amazing Idea Using Lizol Empty Bottle And RGB LED Strip

Tapas Mondal
visit:

0 Comments

Shipped By

Follow Us

Amazing Idea Using Lizol Empty Bottle And RGB LED Strip

Tapas Mondal visit:

0 Comments

Tapas Mondal
visit: