Skip to content

Instantly share code, notes, and snippets.

@samguyer
Created March 1, 2018 02:05
Show Gist options
  • Save samguyer/199a6bb55ab605cd0be4c28e9c47f525 to your computer and use it in GitHub Desktop.
Save samguyer/199a6bb55ab605cd0be4c28e9c47f525 to your computer and use it in GitHub Desktop.
Code for a "fire" (three LED strip flames) triggered by a PIR sensor.
#include <FastLED.h>
#include <adel.h>
#define PIRPIN 6
#define FLAME_1_PIN 3
#define FLAME_1_SIZE 60
#define FLAME_2_PIN 4
#define FLAME_2_SIZE 24
#define FLAME_3_PIN 5
#define FLAME_3_SIZE 51
#define COLOR_ORDER GRB
#define CHIPSET WS2812
#define BRIGHTNESS 220
#define FRAMES_PER_SECOND 60
// -- Color palette for the flames
CRGBPalette16 gPal;
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire. Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
#define SPARKING 150
// --------------------------------------------------------------------------
// Flame class
template<int NUM_LEDS, int LED_PIN>
class Flame
{
private:
CRGB leds[NUM_LEDS];
byte heat[NUM_LEDS];
public:
Flame()
{
for (int i = 0; i < NUM_LEDS; i++) {
heat[i] = 0;
leds[i] = CRGB::Black;
}
}
void init()
{
FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
}
void render(int percent)
{
// Fire2012 by Mark Kriegsman, July 2012
// as part of "Five Elements" shown here: http://youtu.be/knWiGsmgycY
//
// This basic one-dimensional 'fire' simulation works roughly as follows:
// There's a underlying array of 'heat' cells, that model the temperature
// at each point along the line. Every cycle through the simulation,
// four steps are performed:
// 1) All cells cool down a little bit, losing heat to the air
// 2) The heat from each cell drifts 'up' and diffuses a little
// 3) Sometimes randomly new 'sparks' of heat are added at the bottom
// 4) The heat from each cell is rendered as a color into the leds array
// The heat-to-color mapping uses a black-body radiation approximation.
//
// Temperature is in arbitrary units from 0 (cold black) to 255 (white hot).
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames. More cooling = shorter flames.
// Default 55, suggested range 20-100
int cooling = 100 - ((percent * 2) / 3);
int cur_size = (NUM_LEDS * percent + 1) / 100;
// Step 1. Cool down every cell a little
for( int i = 0; i < cur_size; i++) {
heat[i] = qsub8( heat[i], random8(0, ((cooling * 10) / cur_size) + 2));
}
// Step 2. Heat from each cell drifts 'up' and diffuses a little
for( int k= cur_size - 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(100,150) );
}
// Step 4. Map from heat cells to LED colors
for( int j = 0; j < cur_size; j++) {
// Scale the heat value from 0-255 down to 0-240
// for best results with color palettes.
byte colorindex = scale8( heat[j], 170);
CRGB color = ColorFromPalette( gPal, colorindex);
leds[j] = color;
}
for (int j = cur_size; j < NUM_LEDS; j++) {
leds[j] = CRGB::Black;
}
}
};
// Fire2012 with programmable Color Palette
//
// This code is the same fire simulation as the original "Fire2012",
// but each heat cell's temperature is translated to color through a FastLED
// programmable color palette, instead of through the "HeatColor(...)" function.
//
// Four different static color palettes are provided here, plus one dynamic one.
//
// The three static ones are:
// 1. the FastLED built-in HeatColors_p -- this is the default, and it looks
// pretty much exactly like the original Fire2012.
//
// To use any of the other palettes below, just "uncomment" the corresponding code.
//
// 2. a gradient from black to red to yellow to white, which is
// visually similar to the HeatColors_p, and helps to illustrate
// what the 'heat colors' palette is actually doing,
// 3. a similar gradient, but in blue colors rather than red ones,
// i.e. from black to blue to aqua to white, which results in
// an "icy blue" fire effect,
// 4. a simplified three-step gradient, from black to red to white, just to show
// that these gradients need not have four components; two or
// three are possible, too, even if they don't look quite as nice for fire.
//
// The dynamic palette shows how you can change the basic 'hue' of the
// color palette every time through the loop, producing "rainbow fire".
// Add entropy to random number generator; we use a lot of it.
// Fourth, the most sophisticated: this one sets up a new palette every
// time through the loop, based on a hue that changes every time.
// The palette is a gradient from black, to a dark color based on the hue,
// to a light color based on the hue, to white.
//
// static uint8_t hue = 0;
// hue++;
// CRGB darkcolor = CHSV(hue,255,192); // pure hue, three-quarters brightness
// CRGB lightcolor = CHSV(hue,128,255); // half 'whitened', full brightness
// gPal = CRGBPalette16( CRGB::Black, darkcolor, lightcolor, CRGB::White);
// --------------------------------------------------------------------------
// Main logic
// Shelf has three separate flame strips
Flame<FLAME_1_SIZE, FLAME_1_PIN> flame_1;
Flame<FLAME_2_SIZE, FLAME_2_PIN> flame_2;
Flame<FLAME_3_SIZE, FLAME_3_PIN> flame_3;
void setup()
{
delay(500);
Serial.begin(9600);
FastLED.setBrightness( BRIGHTNESS );
// This first palette is the basic 'black body radiation' colors,
// which run from black to red to bright yellow to white.
gPal = HeatColors_p;
// These are other ways to set up the color palette for the 'fire'.
// First, a gradient from black to red to yellow to white -- similar to HeatColors_p
// gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::Yellow, CRGB::White);
// Second, this palette is like the heat colors, but blue/aqua instead of red/yellow
// gPal = CRGBPalette16( CRGB::Black, CRGB::Blue, CRGB::Aqua, CRGB::White);
// Third, here's a simpler, three-step gradient, from black to red to white
// gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::White);
flame_1.init();
flame_2.init();
flame_3.init();
pinMode(PIRPIN, INPUT);
digitalWrite(PIRPIN, LOW);
FastLED.show();
}
/** Render frame
* Render all flames with a frame-rate delay.
*/
adel render_frame(int percent)
{
abegin:
flame_1.render(percent);
flame_2.render(percent);
flame_3.render(percent);
FastLED.show();
adelay(1000/FRAMES_PER_SECOND);
aend;
}
adel render_full()
{
abegin:
while(1) {
andthen( render_frame(100) );
}
aend;
}
/** Burn the man
* Ramp up the flames over several seconds, then ramp them down
* a little more slowly.
*/
adel burn_the_man()
{
int v;
int i;
abegin:
// -- Ramp up the fire
aramp(15000, v, 0, 100) {
andthen( render_frame(v) );
}
// -- Burn for 15 seconds
aforatmost(15000, render_full() );
// -- Ramp down the fire
aramp(30000, v, 100, 0) {
andthen( render_frame(v) );
}
// -- Shut it off
andthen( render_frame(0) );
aend;
}
/** Trigger burn
* Wait for the PIR sensor to be triggered, then burn the man!
*/
adel triggerburn()
{
abegin:
await( digitalRead(PIRPIN) == HIGH);
andthen( burn_the_man() );
aend;
}
void loop()
{
random16_add_entropy( random());
arepeat( triggerburn() );
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment