Best of FastLED Discussions
1. Fire2012： FastLED 火灾模拟器
// Fire2012: a basic fire simulation for a one-dimensional string of LEDs
// Mark Kriegsman, July 2012.
//
// Compiled size for Arduino/AVR is about 3,968 bytes.#include <FastLED.h>#define LED_PIN 5
#define COLOR_ORDER GRB
#define CHIPSET WS2811
#define NUM_LEDS 50#define BRIGHTNESS 200
#define FRAMES_PER_SECOND 60CRGB leds[NUM_LEDS];void setup() {delay(3000); // sanity delayFastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);FastLED.setBrightness( BRIGHTNESS );
}void loop()
{// Add entropy to random number generator; we use a lot of it.random16_add_entropy( random());Fire2012(); // run simulation frameFastLED.show(); // display this frame#if defined(FASTLED_VERSION) && (FASTLED_VERSION >= 2001000)FastLED.delay(1000 / FRAMES_PER_SECOND);
#else delay(1000 / FRAMES_PER_SECOND);
#endif
}// 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).
//
// This simulation scales it self a bit depending on NUM_LEDS; it should look
// "OK" on anywhere from 20 to 100 LEDs without too much tweaking.
//
// I recommend running this simulation at anywhere from 30-100 frames per second,
// meaning an interframe delay of about 10-35 milliseconds.
//
//
// There are two main parameters you can play with to control the look and
// feel of your fire: COOLING (used in step 1 above), and SPARKING (used
// in step 3 above).
//
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames. More cooling = shorter flames.
// Default 55, suggested range 20-100
#define COOLING 55// 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 120void Fire2012()
{
// Array of temperature readings at each simulation cellstatic byte heat[NUM_LEDS];// Step 1. Cool down every cell a littlefor( 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 littlefor( int k= NUM_LEDS - 3; k > 0; k--) {heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;}// Step 3. Randomly ignite new 'sparks' of heat near the bottomif( random8() < SPARKING ) {int y = random8(7);heat[y] = qadd8( heat[y], random8(160,255) );}// Step 4. Map from heat cells to LED colorsfor( int j = 0; j < NUM_LEDS; j++) {leds[j] = HeatColor( heat[j]);}
}// CRGB HeatColor( uint8_t temperature)
// [to be included in the forthcoming FastLED v2.1]
//
// Approximates a 'black body radiation' spectrum for
// a given 'heat' level. This is useful for animations of 'fire'.
// Heat is specified as an arbitrary scale from 0 (cool) to 255 (hot).
// This is NOT a chromatically correct 'black body radiation'
// spectrum, but it's surprisingly close, and it's extremely fast and small.
//
// On AVR/Arduino, this typically takes around 70 bytes of program memory,
// versus 768 bytes for a full 256-entry RGB lookup table.CRGB HeatColor( uint8_t temperature)
{CRGB heatcolor;// Scale 'heat' down from 0-255 to 0-191,// which can then be easily divided into three// equal 'thirds' of 64 units each.uint8_t t192 = scale8_video( temperature, 192);// calculate a value that ramps up from// zero to 255 in each 'third' of the scale.uint8_t heatramp = t192 & 0x3F; // 0..63heatramp <<= 2; // scale up to 0..252// now figure out which third of the spectrum we're in:if( t192 & 0x80) {// we're in the hottest thirdheatcolor.r = 255; // full redheatcolor.g = 255; // full greenheatcolor.b = heatramp; // ramp up blue} else if( t192 & 0x40 ) {// we're in the middle thirdheatcolor.r = 255; // full redheatcolor.g = heatramp; // ramp up greenheatcolor.b = 0; // no blue} else {// we're in the coolest thirdheatcolor.r = heatramp; // ramp up redheatcolor.g = 0; // no greenheatcolor.b = 0; // no blue}return heatcolor;
}
2. 二维 XY 矩阵示例
#include <FastLED.h>#define LED_PIN 5
#define COLOR_ORDER GRB
#define CHIPSET WS2811#define BRIGHTNESS 32const uint8_t kMatrixWidth = 16;
const uint8_t kMatrixHeight = 16;
const bool kMatrixSerpentineLayout = true;#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
CRGB leds[NUM_LEDS];void setup() {FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);FastLED.setBrightness(BRIGHTNESS);
}void loop() {uint32_t ms = millis();int32_t yHueDelta32 = ((int32_t)cos16(ms * 27) * (350 / kMatrixWidth));int32_t xHueDelta32 = ((int32_t)cos16(ms * 39) * (310 / kMatrixHeight));DrawOneFrame(ms / 65536, yHueDelta32 / 32768, xHueDelta32 / 32768);FastLED.show();
}void DrawOneFrame(byte startHue8, int8_t yHueDelta8, int8_t xHueDelta8) {byte lineStartHue = startHue8;for (byte y = 0; y < kMatrixHeight; y++) {lineStartHue += yHueDelta8;byte pixelHue = lineStartHue;for (byte x = 0; x < kMatrixWidth; x++) {pixelHue += xHueDelta8;leds[XY(x, y)] = CHSV(pixelHue, 255, 255);}}
}// Helper function that translates from x, y into an index into the LED array
// Handles both ‘row order’ and ‘serpentine’ pixel layouts.
uint16_t XY(uint8_t x, uint8_t y) {uint16_t i;if (kMatrixSerpentineLayout == false) {i = (y * kMatrixWidth) + x;} else {if (y & 0x01) {// Odd rows run backwardsuint8_t reverseX = (kMatrixWidth - 1) - x;i = (y * kMatrixWidth) + reverseX;} else {// Even rows run forwardsi = (y * kMatrixWidth) + x;}}return i;
}
3. 小数像素渲染
#include <FastLED.h>#define DATA_PIN 6
#define NUM_LEDS 30
CRGB leds[NUM_LEDS];// Anti-aliased light bar example
// v1 by Mark Kriegsman <kriegsman@tr.org>, November 29, 2013
//
// This example shows the basics of using variable pixel brightness
// as a form of anti-aliasing to animate effects on a sub-pixel level,
// which is useful for effects you want to be particularly "smooth".
//
// This animation shows two bars looping around an LED strip, one moving
// in blocky whole-pixel "integer" steps, and the other one moving
// by smoothly anti-aliased "fractional" (1/16th pixel) steps.
// The use of "16ths" (vs, say, 10ths) is totally arbitrary, but 16ths are
// a good balance of data size, expressive range, and code size and speed.
//
// Notionally, "I" is the Integer Bar, "F" is the Fractional Bar.int Ipos = NUM_LEDS / 2; // position of the "integer-based bar"
int Idelta = 1; // how many pixels to move the Integer Bar
uint8_t Ihue = 20; // color for Integer Barint F16pos = 0; // position of the "fraction-based bar"
int F16delta = 1; // how many 16ths of a pixel to move the Fractional Bar
uint8_t Fhue = 20; // color for Fractional Barint Width = 4; // width of each light bar, in whole pixelsint InterframeDelay = 40; //msvoid setup() {delay(3000); // setup guardFastLED.addLeds<WS2811, DATA_PIN, GRB>(leds, NUM_LEDS);FastLED.setBrightness(128);
}// Draw an "Integer Bar" of light starting at pixel 'pos', with given
// width (in whole pixels) and hue.
// This is not the interesting code.
void drawIntegerBar( int intpos, int width, uint8_t hue)
{int i = intpos; // start drawing at "I"for( int n = 0; n < width; n++) {leds[i] += CHSV( hue, 255, 255);i++; if( i == NUM_LEDS) i = 0; // wrap around}
}// Draw a "Fractional Bar" of light starting at position 'pos16', which is counted in
// sixteenths of a pixel from the start of the strip. Fractional positions are
// rendered using 'anti-aliasing' of pixel brightness.
// The bar width is specified in whole pixels.
// Arguably, this is the interesting code.
void drawFractionalBar( int pos16, int width, uint8_t hue)
{int i = pos16 / 16; // convert from pos to raw pixel numberuint8_t frac = pos16 & 0x0F; // extract the 'factional' part of the position // brightness of the first pixel in the bar is 1.0 - (fractional part of position)// e.g., if the light bar starts drawing at pixel "57.9", then // pixel #57 should only be lit at 10% brightness, because only 1/10th of it// is "in" the light bar://// 57.9 . . . . . . . . . . . . . . . . . 61.9// v v// ---+---56----+---57----+---58----+---59----+---60----+---61----+---62---->// | | X|XXXXXXXXX|XXXXXXXXX|XXXXXXXXX|XXXXXXXX | // ---+---------+---------+---------+---------+---------+---------+--------->// 10% 100% 100% 100% 90% //// the fraction we get is in 16ths and needs to be converted to 256ths,// so we multiply by 16. We subtract from 255 because we want a high// fraction (e.g. 0.9) to turn into a low brightness (e.g. 0.1)uint8_t firstpixelbrightness = 255 - (frac * 16);// if the bar is of integer length, the last pixel's brightness is the // reverse of the first pixel's; see illustration above.uint8_t lastpixelbrightness = 255 - firstpixelbrightness;// For a bar of width "N", the code has to consider "N+1" pixel positions,// which is why the "<= width" below instead of "< width".uint8_t bright;for( int n = 0; n <= width; n++) {if( n == 0) {// first pixel in the barbright = firstpixelbrightness;} else if( n == width ) {// last pixel in the barbright = lastpixelbrightness;} else {// middle pixelsbright = 255;}leds[i] += CHSV( hue, 255, bright);i++; if( i == NUM_LEDS) i = 0; // wrap around}
}void loop()
{// Update the "Fraction Bar" by 1/16th pixel every timeF16pos += F16delta;// wrap around at end// remember that F16pos contains position in "16ths of a pixel"// so the 'end of the strip' is (NUM_LEDS * 16)if( F16pos >= (NUM_LEDS * 16)) {F16pos -= (NUM_LEDS * 16);}// For this demo, we want the Integer Bar and the Fraciton Bar// to move at the same speed down the strip.// The Fraction Bar moves 1/16th of a pixel each time through the // loop, so to get the same speed on the strip for the Integer Bar, // we need to move it by 1 full pixel -- but only every 16 times// through the loop. 'countdown' is used to tell when it's time// to advance the Integer Bar position again.static byte countdown = 0;if( countdown == 0) {countdown = 16; // reset countdown// advance Integer Bar one full pixel nowIpos += 1;// wrap around at endif( Ipos >= NUM_LEDS) {Ipos -= NUM_LEDS; } }// countdown is decremented every time through the loopcountdown -= 1;// Draw everything:// clear the pixel buffermemset8( leds, 0, NUM_LEDS * sizeof(CRGB));// draw the Integer Bar, length=4px, hue=180drawIntegerBar( Ipos, Width, Ihue);// draw the Fractional Bar, length=4px, hue=180drawFractionalBar( F16pos, Width, Fhue);FastLED.show();delay(InterframeDelay);
}
)