des veilleuses en céramique

[code lang= »arduino »]

/**
* Arduino Uno – Veilleuse Diastem
* v. 1.0
* Copyright (C) 2016 Laure & Christophe Sivadier
*
* Code inspired by buttoncycler example from Adafruit_Neopixel
* Fire Effect by Robert Ulbricht http://www.arduinoslovakia.eu/blog/2015/9/simulacia-ohna?lang=en
* Drop Effect inspired by https://gist.github.com/suhajdab/9716028
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <Adafruit_NeoPixel.h>

#define BUTTON_PIN   2
#define PIN 0
#define Pixels 9 // 9 pour dodecaedre, 12 pour icosaedre
Adafruit_NeoPixel strip = Adafruit_NeoPixel(Pixels, PIN, NEO_GRB + NEO_KHZ800);

///////////////////
///////////////////
/////* SETUP */////
///////////////////
///////////////////

bool oldState = LOW;
bool active = HIGH;

float redStates[Pixels];
float blueStates[Pixels];
float greenStates[Pixels];
float fadeRate = 0.95;

void setup() {
pinMode(BUTTON_PIN, INPUT_PULLUP);
strip.begin();
strip.show();
}

///////////////////
///////////////////
/////* LOOP *//////
///////////////////
///////////////////

void loop() {
rainbow(100);
debounce();
rainbowCycle(50);
debounce();
fire(225, 70, 25); // Orange flame
debounce();
fire(158, 8, 148); // Purple flame
debounce();
fire(74, 150, 12); // Green flame
debounce();
fire(226, 15, 30); // Red flame
debounce();
drops();
debounce();
couleur(strip.Color(255, 255, 255), 50);
debounce();
couleur(strip.Color(0, 0, 0), 50);
debounce();
}

//******************
//******************
//****** VOID ******
//******************
//******************

////////////////////
////////////////////
/// SIMPLE COLOR ///
////////////////////
////////////////////

void couleur(uint32_t c, uint8_t wait) {
for(;;) {
for(uint8_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}
}

///////////////////
///////////////////
//// RAINBOW 1 ////
///////////////////
///////////////////

void rainbow(uint8_t wait) {
for(;;) {
for (uint16_t j = 0; j < 256; j++) {
for (uint8_t i = 0; i < strip.numPixels(); i++) {
strip.setPixelColor(i, Wheel((i + j) & 255));
}

strip.show();
delay(wait);

if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}
}

///////////////////
///////////////////
//// RAINBOW 2 ////
///////////////////
///////////////////

void rainbowCycle(uint8_t wait) {
for(;;) {
for(uint16_t j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
for(uint16_t i=0; i< strip.numPixels(); i++) {
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
}
strip.show();
delay(wait);
if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}
}

///////////////////
///////////////////
////// DROPS //////
///////////////////
///////////////////

void drops(){

for(;;) {
for(int x=0; x<400; x++) {
if (random(20) == 1) {
uint8_t i = random(Pixels);
if (redStates[i] < 1 && greenStates[i] < 1 && blueStates[i] < 1) {
redStates[i] = 0; // random(256)
greenStates[i] = random(256);
blueStates[i] = random(256);
}
}

for(uint16_t l = 0; l < Pixels; l++) {
if (redStates[l] > 1 || greenStates[l] > 1 || blueStates[l] > 1) {
strip.setPixelColor(l, redStates[l], greenStates[l], blueStates[l]);

if (redStates[l] > 1) {
redStates[l] = redStates[l] * fadeRate;
}
else {
redStates[l] = 0;
}

if (greenStates[l] > 1) {
greenStates[l] = greenStates[l] * fadeRate;
}
else {
greenStates[l] = 0;
}

if (blueStates[l] > 1) {
blueStates[l] = blueStates[l] * fadeRate;
}
else {
blueStates[l] = 0;
}

}
else {
strip.setPixelColor(l, 0, 10, 10);
}
}
strip.show();
delay(35);
if(digitalRead(BUTTON_PIN) == active) {
return;
}

}
}
}

///////////////////
///////////////////
// FIRE  EFFECT ///
///////////////////
///////////////////
void fire(byte r, byte g, byte b){
for(;;) {
for(byte i=0; i<strip.numPixels(); i++) {

int flicker = random(0,55);
int r1 = r-flicker;
int g1 = g-flicker;
int b1 = b-flicker;
if(g1<0) g1=0;
if(r1<0) r1=0;
if(b1<0) b1=0;
strip.setPixelColor(i,r1,g1, b1);
}
strip.show();
delay(random(10,113));
if(digitalRead(BUTTON_PIN) == active) {
return;
}
}
}

//////////////////////
//////////////////////
/// RAINBOW WHEEL ////
//////////////////////
//////////////////////

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 //////
////////////////////
////////////////////

void debounce() {
byte start = millis();
while(millis() – start < 20UL) {
if(digitalRead(BUTTON_PIN) == active) {
start = millis();
}
}
delay(500);
}

[/code]