Code for a "fire" (three LED strip flames) triggered by a PIR sensor.

BurningShelf.cpp

#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() );
}