mirror of
https://github.com/AlexGyver/GyverLamp2.git
synced 2025-08-07 16:50:35 +03:00
add
This commit is contained in:
@@ -0,0 +1,65 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
// Example showing how to use FastLED color functions
|
||||
// even when you're NOT using a "pixel-addressible" smart LED strip.
|
||||
//
|
||||
// This example is designed to control an "analog" RGB LED strip
|
||||
// (or a single RGB LED) being driven by Arduino PWM output pins.
|
||||
// So this code never calls FastLED.addLEDs() or FastLED.show().
|
||||
//
|
||||
// This example illustrates one way you can use just the portions
|
||||
// of FastLED that you need. In this case, this code uses just the
|
||||
// fast HSV color conversion code.
|
||||
//
|
||||
// In this example, the RGB values are output on three separate
|
||||
// 'analog' PWM pins, one for red, one for green, and one for blue.
|
||||
|
||||
#define REDPIN 5
|
||||
#define GREENPIN 6
|
||||
#define BLUEPIN 3
|
||||
|
||||
// showAnalogRGB: this is like FastLED.show(), but outputs on
|
||||
// analog PWM output pins instead of sending data to an intelligent,
|
||||
// pixel-addressable LED strip.
|
||||
//
|
||||
// This function takes the incoming RGB values and outputs the values
|
||||
// on three analog PWM output pins to the r, g, and b values respectively.
|
||||
void showAnalogRGB( const CRGB& rgb)
|
||||
{
|
||||
analogWrite(REDPIN, rgb.r );
|
||||
analogWrite(GREENPIN, rgb.g );
|
||||
analogWrite(BLUEPIN, rgb.b );
|
||||
}
|
||||
|
||||
|
||||
|
||||
// colorBars: flashes Red, then Green, then Blue, then Black.
|
||||
// Helpful for diagnosing if you've mis-wired which is which.
|
||||
void colorBars()
|
||||
{
|
||||
showAnalogRGB( CRGB::Red ); delay(500);
|
||||
showAnalogRGB( CRGB::Green ); delay(500);
|
||||
showAnalogRGB( CRGB::Blue ); delay(500);
|
||||
showAnalogRGB( CRGB::Black ); delay(500);
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
static uint8_t hue;
|
||||
hue = hue + 1;
|
||||
// Use FastLED automatic HSV->RGB conversion
|
||||
showAnalogRGB( CHSV( hue, 255, 255) );
|
||||
|
||||
delay(20);
|
||||
}
|
||||
|
||||
|
||||
void setup() {
|
||||
pinMode(REDPIN, OUTPUT);
|
||||
pinMode(GREENPIN, OUTPUT);
|
||||
pinMode(BLUEPIN, OUTPUT);
|
||||
|
||||
// Flash the "hello" color sequence: R, G, B, black.
|
||||
colorBars();
|
||||
}
|
||||
|
69
libraries/FastLED-3.4.0/examples/Blink/Blink.ino
Normal file
69
libraries/FastLED-3.4.0/examples/Blink/Blink.ino
Normal file
@@ -0,0 +1,69 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
// How many leds in your strip?
|
||||
#define NUM_LEDS 1
|
||||
|
||||
// For led chips like WS2812, which have a data line, ground, and power, you just
|
||||
// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,
|
||||
// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN
|
||||
// Clock pin only needed for SPI based chipsets when not using hardware SPI
|
||||
#define DATA_PIN 3
|
||||
#define CLOCK_PIN 13
|
||||
|
||||
// Define the array of leds
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
void setup() {
|
||||
// Uncomment/edit one of the following lines for your leds arrangement.
|
||||
// ## Clockless types ##
|
||||
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS); // GRB ordering is assumed
|
||||
// FastLED.addLeds<SM16703, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1829, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1812, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1903B, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1904, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS2903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2852, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<GS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SK6812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<APA106, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<PL9823, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2813, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<APA104, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2811_400, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GE8822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GW6205, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GW6205_400, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<LPD1886, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<LPD1886_8BIT, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// ## Clocked (SPI) types ##
|
||||
// FastLED.addLeds<LPD6803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<SK9822, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Turn the LED on, then pause
|
||||
leds[0] = CRGB::Red;
|
||||
FastLED.show();
|
||||
delay(500);
|
||||
// Now turn the LED off, then pause
|
||||
leds[0] = CRGB::Black;
|
||||
FastLED.show();
|
||||
delay(500);
|
||||
}
|
188
libraries/FastLED-3.4.0/examples/ColorPalette/ColorPalette.ino
Normal file
188
libraries/FastLED-3.4.0/examples/ColorPalette/ColorPalette.ino
Normal file
@@ -0,0 +1,188 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define LED_PIN 5
|
||||
#define NUM_LEDS 50
|
||||
#define BRIGHTNESS 64
|
||||
#define LED_TYPE WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
#define UPDATES_PER_SECOND 100
|
||||
|
||||
// This example shows several ways to set up and use 'palettes' of colors
|
||||
// with FastLED.
|
||||
//
|
||||
// These compact palettes provide an easy way to re-colorize your
|
||||
// animation on the fly, quickly, easily, and with low overhead.
|
||||
//
|
||||
// USING palettes is MUCH simpler in practice than in theory, so first just
|
||||
// run this sketch, and watch the pretty lights as you then read through
|
||||
// the code. Although this sketch has eight (or more) different color schemes,
|
||||
// the entire sketch compiles down to about 6.5K on AVR.
|
||||
//
|
||||
// FastLED provides a few pre-configured color palettes, and makes it
|
||||
// extremely easy to make up your own color schemes with palettes.
|
||||
//
|
||||
// Some notes on the more abstract 'theory and practice' of
|
||||
// FastLED compact palettes are at the bottom of this file.
|
||||
|
||||
|
||||
|
||||
CRGBPalette16 currentPalette;
|
||||
TBlendType currentBlending;
|
||||
|
||||
extern CRGBPalette16 myRedWhiteBluePalette;
|
||||
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
|
||||
|
||||
|
||||
void setup() {
|
||||
delay( 3000 ); // power-up safety delay
|
||||
FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
|
||||
FastLED.setBrightness( BRIGHTNESS );
|
||||
|
||||
currentPalette = RainbowColors_p;
|
||||
currentBlending = LINEARBLEND;
|
||||
}
|
||||
|
||||
|
||||
void loop()
|
||||
{
|
||||
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.
|
@@ -0,0 +1,85 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define LED_PIN 3
|
||||
|
||||
// Information about the LED strip itself
|
||||
#define NUM_LEDS 60
|
||||
#define CHIPSET WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
#define BRIGHTNESS 128
|
||||
|
||||
|
||||
// FastLED v2.1 provides two color-management controls:
|
||||
// (1) color correction settings for each LED strip, and
|
||||
// (2) master control of the overall output 'color temperature'
|
||||
//
|
||||
// THIS EXAMPLE demonstrates the second, "color temperature" control.
|
||||
// It shows a simple rainbow animation first with one temperature profile,
|
||||
// and a few seconds later, with a different temperature profile.
|
||||
//
|
||||
// The first pixel of the strip will show the color temperature.
|
||||
//
|
||||
// HELPFUL HINTS for "seeing" the effect in this demo:
|
||||
// * Don't look directly at the LED pixels. Shine the LEDs aganst
|
||||
// a white wall, table, or piece of paper, and look at the reflected light.
|
||||
//
|
||||
// * If you watch it for a bit, and then walk away, and then come back
|
||||
// to it, you'll probably be able to "see" whether it's currently using
|
||||
// the 'redder' or the 'bluer' temperature profile, even not counting
|
||||
// the lowest 'indicator' pixel.
|
||||
//
|
||||
//
|
||||
// FastLED provides these pre-conigured incandescent color profiles:
|
||||
// Candle, Tungsten40W, Tungsten100W, Halogen, CarbonArc,
|
||||
// HighNoonSun, DirectSunlight, OvercastSky, ClearBlueSky,
|
||||
// FastLED provides these pre-configured gaseous-light color profiles:
|
||||
// WarmFluorescent, StandardFluorescent, CoolWhiteFluorescent,
|
||||
// FullSpectrumFluorescent, GrowLightFluorescent, BlackLightFluorescent,
|
||||
// MercuryVapor, SodiumVapor, MetalHalide, HighPressureSodium,
|
||||
// FastLED also provides an "Uncorrected temperature" profile
|
||||
// UncorrectedTemperature;
|
||||
|
||||
#define TEMPERATURE_1 Tungsten100W
|
||||
#define TEMPERATURE_2 OvercastSky
|
||||
|
||||
// How many seconds to show each temperature before switching
|
||||
#define DISPLAYTIME 20
|
||||
// How many seconds to show black between switches
|
||||
#define BLACKTIME 3
|
||||
|
||||
void loop()
|
||||
{
|
||||
// draw a generic, no-name rainbow
|
||||
static uint8_t starthue = 0;
|
||||
fill_rainbow( leds + 5, NUM_LEDS - 5, --starthue, 20);
|
||||
|
||||
// Choose which 'color temperature' profile to enable.
|
||||
uint8_t secs = (millis() / 1000) % (DISPLAYTIME * 2);
|
||||
if( secs < DISPLAYTIME) {
|
||||
FastLED.setTemperature( TEMPERATURE_1 ); // first temperature
|
||||
leds[0] = TEMPERATURE_1; // show indicator pixel
|
||||
} else {
|
||||
FastLED.setTemperature( TEMPERATURE_2 ); // second temperature
|
||||
leds[0] = TEMPERATURE_2; // show indicator pixel
|
||||
}
|
||||
|
||||
// Black out the LEDs for a few secnds between color changes
|
||||
// to let the eyes and brains adjust
|
||||
if( (secs % DISPLAYTIME) < BLACKTIME) {
|
||||
memset8( leds, 0, NUM_LEDS * sizeof(CRGB));
|
||||
}
|
||||
|
||||
FastLED.show();
|
||||
FastLED.delay(8);
|
||||
}
|
||||
|
||||
void setup() {
|
||||
delay( 3000 ); // power-up safety delay
|
||||
// It's important to set the color correction for your LED strip here,
|
||||
// so that colors can be more accurately rendered through the 'temperature' profiles
|
||||
FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalSMD5050 );
|
||||
FastLED.setBrightness( BRIGHTNESS );
|
||||
}
|
||||
|
53
libraries/FastLED-3.4.0/examples/Cylon/Cylon.ino
Normal file
53
libraries/FastLED-3.4.0/examples/Cylon/Cylon.ino
Normal file
@@ -0,0 +1,53 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
// How many leds in your strip?
|
||||
#define NUM_LEDS 64
|
||||
|
||||
// For led chips like Neopixels, which have a data line, ground, and power, you just
|
||||
// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,
|
||||
// ground, and power), like the LPD8806, define both DATA_PIN and CLOCK_PIN
|
||||
#define DATA_PIN 7
|
||||
#define CLOCK_PIN 13
|
||||
|
||||
// Define the array of leds
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
void setup() {
|
||||
Serial.begin(57600);
|
||||
Serial.println("resetting");
|
||||
LEDS.addLeds<WS2812,DATA_PIN,RGB>(leds,NUM_LEDS);
|
||||
LEDS.setBrightness(84);
|
||||
}
|
||||
|
||||
void fadeall() { for(int i = 0; i < NUM_LEDS; i++) { leds[i].nscale8(250); } }
|
||||
|
||||
void loop() {
|
||||
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(10);
|
||||
}
|
||||
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(10);
|
||||
}
|
||||
}
|
126
libraries/FastLED-3.4.0/examples/DemoReel100/DemoReel100.ino
Normal file
126
libraries/FastLED-3.4.0/examples/DemoReel100/DemoReel100.ino
Normal file
@@ -0,0 +1,126 @@
|
||||
#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 3
|
||||
//#define CLK_PIN 4
|
||||
#define LED_TYPE WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
#define NUM_LEDS 64
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
#define BRIGHTNESS 96
|
||||
#define FRAMES_PER_SECOND 120
|
||||
|
||||
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 = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm };
|
||||
|
||||
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( 10 ) { 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;
|
||||
}
|
||||
}
|
||||
|
105
libraries/FastLED-3.4.0/examples/Fire2012/Fire2012.ino
Normal file
105
libraries/FastLED-3.4.0/examples/Fire2012/Fire2012.ino
Normal file
@@ -0,0 +1,105 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define LED_PIN 5
|
||||
#define COLOR_ORDER GRB
|
||||
#define CHIPSET WS2811
|
||||
#define NUM_LEDS 30
|
||||
|
||||
#define BRIGHTNESS 200
|
||||
#define FRAMES_PER_SECOND 60
|
||||
|
||||
bool gReverseDirection = false;
|
||||
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
void setup() {
|
||||
delay(3000); // sanity delay
|
||||
FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
|
||||
FastLED.setBrightness( BRIGHTNESS );
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
// Add entropy to random number generator; we use a lot of it.
|
||||
// random16_add_entropy( random());
|
||||
|
||||
Fire2012(); // run simulation frame
|
||||
|
||||
FastLED.show(); // display this frame
|
||||
FastLED.delay(1000 / FRAMES_PER_SECOND);
|
||||
}
|
||||
|
||||
|
||||
// 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.
|
||||
//
|
||||
// Looks best on a high-density LED setup (60+ pixels/meter).
|
||||
//
|
||||
//
|
||||
// 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 50, 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 120
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
@@ -0,0 +1,164 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define LED_PIN 5
|
||||
#define COLOR_ORDER GRB
|
||||
#define CHIPSET WS2811
|
||||
#define NUM_LEDS 30
|
||||
|
||||
#define BRIGHTNESS 200
|
||||
#define FRAMES_PER_SECOND 60
|
||||
|
||||
bool gReverseDirection = false;
|
||||
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
// 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".
|
||||
|
||||
CRGBPalette16 gPal;
|
||||
|
||||
void setup() {
|
||||
delay(3000); // sanity delay
|
||||
FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
// Add entropy to random number generator; we use a lot of it.
|
||||
random16_add_entropy( random());
|
||||
|
||||
// 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);
|
||||
|
||||
|
||||
Fire2012WithPalette(); // run simulation frame, using palette colors
|
||||
|
||||
FastLED.show(); // display this frame
|
||||
FastLED.delay(1000 / FRAMES_PER_SECOND);
|
||||
}
|
||||
|
||||
|
||||
// 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.
|
||||
//
|
||||
// Looks best on a high-density LED setup (60+ pixels/meter).
|
||||
//
|
||||
//
|
||||
// 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 120
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
92
libraries/FastLED-3.4.0/examples/FirstLight/FirstLight.ino
Normal file
92
libraries/FastLED-3.4.0/examples/FirstLight/FirstLight.ino
Normal file
@@ -0,0 +1,92 @@
|
||||
// Use if you want to force the software SPI subsystem to be used for some reason (generally, you don't)
|
||||
// #define FASTLED_FORCE_SOFTWARE_SPI
|
||||
// Use if you want to force non-accelerated pin access (hint: you really don't, it breaks lots of things)
|
||||
// #define FASTLED_FORCE_SOFTWARE_SPI
|
||||
// #define FASTLED_FORCE_SOFTWARE_PINS
|
||||
#include <FastLED.h>
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Move a white dot along the strip of leds. This program simply shows how to configure the leds,
|
||||
// and then how to turn a single pixel white and then off, moving down the line of pixels.
|
||||
//
|
||||
|
||||
// How many leds are in the strip?
|
||||
#define NUM_LEDS 60
|
||||
|
||||
// For led chips like WS2812, which have a data line, ground, and power, you just
|
||||
// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,
|
||||
// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN
|
||||
// Clock pin only needed for SPI based chipsets when not using hardware SPI
|
||||
#define DATA_PIN 3
|
||||
#define CLOCK_PIN 13
|
||||
|
||||
// This is an array of leds. One item for each led in your strip.
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
// This function sets up the ledsand tells the controller about them
|
||||
void setup() {
|
||||
// sanity check delay - allows reprogramming if accidently blowing power w/leds
|
||||
delay(2000);
|
||||
|
||||
// Uncomment/edit one of the following lines for your leds arrangement.
|
||||
// ## Clockless types ##
|
||||
// FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS); // GRB ordering is assumed
|
||||
// FastLED.addLeds<SM16703, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1829, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1812, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1903B, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1904, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS2903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2852, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<GS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SK6812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<APA106, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<PL9823, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2813, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<APA104, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2811_400, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GE8822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GW6205, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GW6205_400, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<LPD1886, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<LPD1886_8BIT, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// ## Clocked (SPI) types ##
|
||||
// FastLED.addLeds<LPD6803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<SK9822, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
}
|
||||
|
||||
// This function runs over and over, and is where you do the magic to light
|
||||
// your leds.
|
||||
void loop() {
|
||||
// Move a single white led
|
||||
for(int whiteLed = 0; whiteLed < NUM_LEDS; whiteLed = whiteLed + 1) {
|
||||
// Turn our current led on to white, then show the leds
|
||||
leds[whiteLed] = CRGB::White;
|
||||
|
||||
// Show the leds (only one of which is set to white, from above)
|
||||
FastLED.show();
|
||||
|
||||
// Wait a little bit
|
||||
delay(100);
|
||||
|
||||
// Turn our current led back to black for the next loop around
|
||||
leds[whiteLed] = CRGB::Black;
|
||||
}
|
||||
}
|
@@ -0,0 +1,37 @@
|
||||
// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
|
||||
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
|
||||
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
|
||||
// to be all parts of an array of arrays.
|
||||
|
||||
#include <FastLED.h>
|
||||
|
||||
#define NUM_STRIPS 3
|
||||
#define NUM_LEDS_PER_STRIP 60
|
||||
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];
|
||||
|
||||
// For mirroring strips, all the "special" stuff happens just in setup. We
|
||||
// just addLeds multiple times, once for each strip
|
||||
void setup() {
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 10
|
||||
FastLED.addLeds<NEOPIXEL, 10>(leds[0], NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 11
|
||||
FastLED.addLeds<NEOPIXEL, 11>(leds[1], NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 12
|
||||
FastLED.addLeds<NEOPIXEL, 12>(leds[2], NUM_LEDS_PER_STRIP);
|
||||
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// This outer loop will go over each strip, one at a time
|
||||
for(int x = 0; x < NUM_STRIPS; x++) {
|
||||
// This inner loop will go over each led in the current strip, one at a time
|
||||
for(int i = 0; i < NUM_LEDS_PER_STRIP; i++) {
|
||||
leds[x][i] = CRGB::Red;
|
||||
FastLED.show();
|
||||
leds[x][i] = CRGB::Black;
|
||||
delay(100);
|
||||
}
|
||||
}
|
||||
}
|
@@ -0,0 +1,44 @@
|
||||
// MirroringSample - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
|
||||
// using multiple controllers. In this example, we're going to set up four NEOPIXEL strips on four
|
||||
// different pins, and show the same thing on all four of them, a simple bouncing dot/cyclon type pattern
|
||||
|
||||
#include <FastLED.h>
|
||||
|
||||
#define NUM_LEDS_PER_STRIP 60
|
||||
CRGB leds[NUM_LEDS_PER_STRIP];
|
||||
|
||||
// For mirroring strips, all the "special" stuff happens just in setup. We
|
||||
// just addLeds multiple times, once for each strip
|
||||
void setup() {
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 4
|
||||
FastLED.addLeds<NEOPIXEL, 4>(leds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 5
|
||||
FastLED.addLeds<NEOPIXEL, 5>(leds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 6
|
||||
FastLED.addLeds<NEOPIXEL, 6>(leds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 7
|
||||
FastLED.addLeds<NEOPIXEL, 7>(leds, NUM_LEDS_PER_STRIP);
|
||||
}
|
||||
|
||||
void loop() {
|
||||
for(int i = 0; i < NUM_LEDS_PER_STRIP; i++) {
|
||||
// set our current dot to red
|
||||
leds[i] = CRGB::Red;
|
||||
FastLED.show();
|
||||
// clear our current dot before we move on
|
||||
leds[i] = CRGB::Black;
|
||||
delay(100);
|
||||
}
|
||||
|
||||
for(int i = NUM_LEDS_PER_STRIP-1; i >= 0; i--) {
|
||||
// set our current dot to red
|
||||
leds[i] = CRGB::Red;
|
||||
FastLED.show();
|
||||
// clear our current dot before we move on
|
||||
leds[i] = CRGB::Black;
|
||||
delay(100);
|
||||
}
|
||||
}
|
@@ -0,0 +1,52 @@
|
||||
// MultiArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
|
||||
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
|
||||
// different pins, each strip getting its own CRGB array to be played with
|
||||
|
||||
#include <FastLED.h>
|
||||
|
||||
#define NUM_LEDS_PER_STRIP 60
|
||||
CRGB redLeds[NUM_LEDS_PER_STRIP];
|
||||
CRGB greenLeds[NUM_LEDS_PER_STRIP];
|
||||
CRGB blueLeds[NUM_LEDS_PER_STRIP];
|
||||
|
||||
// For mirroring strips, all the "special" stuff happens just in setup. We
|
||||
// just addLeds multiple times, once for each strip
|
||||
void setup() {
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 10
|
||||
FastLED.addLeds<NEOPIXEL, 10>(redLeds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 11
|
||||
FastLED.addLeds<NEOPIXEL, 11>(greenLeds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 12
|
||||
FastLED.addLeds<NEOPIXEL, 12>(blueLeds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
}
|
||||
|
||||
void loop() {
|
||||
for(int i = 0; i < NUM_LEDS_PER_STRIP; i++) {
|
||||
// set our current dot to red, green, and blue
|
||||
redLeds[i] = CRGB::Red;
|
||||
greenLeds[i] = CRGB::Green;
|
||||
blueLeds[i] = CRGB::Blue;
|
||||
FastLED.show();
|
||||
// clear our current dot before we move on
|
||||
redLeds[i] = CRGB::Black;
|
||||
greenLeds[i] = CRGB::Black;
|
||||
blueLeds[i] = CRGB::Black;
|
||||
delay(100);
|
||||
}
|
||||
|
||||
for(int i = NUM_LEDS_PER_STRIP-1; i >= 0; i--) {
|
||||
// set our current dot to red, green, and blue
|
||||
redLeds[i] = CRGB::Red;
|
||||
greenLeds[i] = CRGB::Green;
|
||||
blueLeds[i] = CRGB::Blue;
|
||||
FastLED.show();
|
||||
// clear our current dot before we move on
|
||||
redLeds[i] = CRGB::Black;
|
||||
greenLeds[i] = CRGB::Black;
|
||||
blueLeds[i] = CRGB::Black;
|
||||
delay(100);
|
||||
}
|
||||
}
|
@@ -0,0 +1,34 @@
|
||||
// MultipleStripsInOneArray - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
|
||||
// using multiple controllers. In this example, we're going to set up four NEOPIXEL strips on three
|
||||
// different pins, each strip will be referring to a different part of the single led array
|
||||
|
||||
#include <FastLED.h>
|
||||
|
||||
#define NUM_STRIPS 3
|
||||
#define NUM_LEDS_PER_STRIP 60
|
||||
#define NUM_LEDS NUM_LEDS_PER_STRIP * NUM_STRIPS
|
||||
|
||||
CRGB leds[NUM_STRIPS * NUM_LEDS_PER_STRIP];
|
||||
|
||||
// For mirroring strips, all the "special" stuff happens just in setup. We
|
||||
// just addLeds multiple times, once for each strip
|
||||
void setup() {
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 10, starting at index 0 in the led array
|
||||
FastLED.addLeds<NEOPIXEL, 10>(leds, 0, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 11, starting at index 60 in the led array
|
||||
FastLED.addLeds<NEOPIXEL, 11>(leds, NUM_LEDS_PER_STRIP, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// tell FastLED there's 60 NEOPIXEL leds on pin 12, starting at index 120 in the led array
|
||||
FastLED.addLeds<NEOPIXEL, 12>(leds, 2 * NUM_LEDS_PER_STRIP, NUM_LEDS_PER_STRIP);
|
||||
|
||||
}
|
||||
|
||||
void loop() {
|
||||
for(int i = 0; i < NUM_LEDS; i++) {
|
||||
leds[i] = CRGB::Red;
|
||||
FastLED.show();
|
||||
leds[i] = CRGB::Black;
|
||||
delay(100);
|
||||
}
|
||||
}
|
@@ -0,0 +1,37 @@
|
||||
#define USE_OCTOWS2811
|
||||
#include <OctoWS2811.h>
|
||||
#include <FastLED.h>
|
||||
|
||||
#define NUM_LEDS_PER_STRIP 64
|
||||
#define NUM_STRIPS 8
|
||||
|
||||
CRGB leds[NUM_STRIPS * NUM_LEDS_PER_STRIP];
|
||||
|
||||
// Pin layouts on the teensy 3:
|
||||
// OctoWS2811: 2,14,7,8,6,20,21,5
|
||||
|
||||
void setup() {
|
||||
LEDS.addLeds<OCTOWS2811>(leds, NUM_LEDS_PER_STRIP);
|
||||
LEDS.setBrightness(32);
|
||||
}
|
||||
|
||||
void loop() {
|
||||
static uint8_t hue = 0;
|
||||
for(int i = 0; i < NUM_STRIPS; i++) {
|
||||
for(int j = 0; j < NUM_LEDS_PER_STRIP; j++) {
|
||||
leds[(i*NUM_LEDS_PER_STRIP) + j] = CHSV((32*i) + hue+j,192,255);
|
||||
}
|
||||
}
|
||||
|
||||
// Set the first n leds on each strip to show which strip it is
|
||||
for(int i = 0; i < NUM_STRIPS; i++) {
|
||||
for(int j = 0; j <= i; j++) {
|
||||
leds[(i*NUM_LEDS_PER_STRIP) + j] = CRGB::Red;
|
||||
}
|
||||
}
|
||||
|
||||
hue++;
|
||||
|
||||
LEDS.show();
|
||||
LEDS.delay(10);
|
||||
}
|
@@ -0,0 +1,56 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define NUM_LEDS_PER_STRIP 16
|
||||
// Note: this can be 12 if you're using a teensy 3 and don't mind soldering the pads on the back
|
||||
#define NUM_STRIPS 16
|
||||
|
||||
CRGB leds[NUM_STRIPS * NUM_LEDS_PER_STRIP];
|
||||
|
||||
// Pin layouts on the teensy 3/3.1:
|
||||
// WS2811_PORTD: 2,14,7,8,6,20,21,5
|
||||
// WS2811_PORTC: 15,22,23,9,10,13,11,12,28,27,29,30 (these last 4 are pads on the bottom of the teensy)
|
||||
// WS2811_PORTDC: 2,14,7,8,6,20,21,5,15,22,23,9,10,13,11,12 - 16 way parallel
|
||||
//
|
||||
// Pin layouts on the due
|
||||
// WS2811_PORTA: 69,68,61,60,59,100,58,31 (note: pin 100 only available on the digix)
|
||||
// WS2811_PORTB: 90,91,92,93,94,95,96,97 (note: only available on the digix)
|
||||
// WS2811_PORTD: 25,26,27,28,14,15,29,11
|
||||
//
|
||||
|
||||
|
||||
// IBCC<WS2811, 1, 16> outputs;
|
||||
|
||||
void setup() {
|
||||
delay(5000);
|
||||
Serial.begin(57600);
|
||||
Serial.println("Starting...");
|
||||
// LEDS.addLeds<WS2811_PORTA,NUM_STRIPS>(leds, NUM_LEDS_PER_STRIP);
|
||||
// LEDS.addLeds<WS2811_PORTB,NUM_STRIPS>(leds, NUM_LEDS_PER_STRIP);
|
||||
// LEDS.addLeds<WS2811_PORTD,NUM_STRIPS>(leds, NUM_LEDS_PER_STRIP).setCorrection(TypicalLEDStrip);
|
||||
LEDS.addLeds<WS2811_PORTDC,NUM_STRIPS>(leds, NUM_LEDS_PER_STRIP);
|
||||
|
||||
// Teensy 4 parallel output example
|
||||
// LEDS.addLeds<NUM_STRIPS, WS2811, 1>(leds,NUM_LEDS_PER_STRIP);
|
||||
}
|
||||
|
||||
void loop() {
|
||||
Serial.println("Loop....");
|
||||
static uint8_t hue = 0;
|
||||
for(int i = 0; i < NUM_STRIPS; i++) {
|
||||
for(int j = 0; j < NUM_LEDS_PER_STRIP; j++) {
|
||||
leds[(i*NUM_LEDS_PER_STRIP) + j] = CHSV((32*i) + hue+j,192,255);
|
||||
}
|
||||
}
|
||||
|
||||
// Set the first n leds on each strip to show which strip it is
|
||||
for(int i = 0; i < NUM_STRIPS; i++) {
|
||||
for(int j = 0; j <= i; j++) {
|
||||
leds[(i*NUM_LEDS_PER_STRIP) + j] = CRGB::Red;
|
||||
}
|
||||
}
|
||||
|
||||
hue++;
|
||||
|
||||
LEDS.show();
|
||||
// LEDS.delay(100);
|
||||
}
|
112
libraries/FastLED-3.4.0/examples/Noise/Noise.ino
Normal file
112
libraries/FastLED-3.4.0/examples/Noise/Noise.ino
Normal file
@@ -0,0 +1,112 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
//
|
||||
// Mark's xy coordinate mapping code. See the XYMatrix for more information on it.
|
||||
//
|
||||
|
||||
// Params for width and height
|
||||
const uint8_t kMatrixWidth = 16;
|
||||
const uint8_t kMatrixHeight = 16;
|
||||
#define MAX_DIMENSION ((kMatrixWidth>kMatrixHeight) ? kMatrixWidth : kMatrixHeight)
|
||||
#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
|
||||
// Param for different pixel layouts
|
||||
const bool kMatrixSerpentineLayout = true;
|
||||
|
||||
|
||||
uint16_t XY( uint8_t x, uint8_t y)
|
||||
{
|
||||
uint16_t i;
|
||||
|
||||
if( kMatrixSerpentineLayout == false) {
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
|
||||
if( kMatrixSerpentineLayout == true) {
|
||||
if( y & 0x01) {
|
||||
// Odd rows run backwards
|
||||
uint8_t reverseX = (kMatrixWidth - 1) - x;
|
||||
i = (y * kMatrixWidth) + reverseX;
|
||||
} else {
|
||||
// Even rows run forwards
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
// The leds
|
||||
CRGB leds[kMatrixWidth * kMatrixHeight];
|
||||
|
||||
// The 32bit version of our coordinates
|
||||
static uint16_t x;
|
||||
static uint16_t y;
|
||||
static uint16_t z;
|
||||
|
||||
// We're using the x/y dimensions to map to the x/y pixels on the matrix. We'll
|
||||
// use the z-axis for "time". speed determines how fast time moves forward. Try
|
||||
// 1 for a very slow moving effect, or 60 for something that ends up looking like
|
||||
// water.
|
||||
// uint16_t speed = 1; // almost looks like a painting, moves very slowly
|
||||
uint16_t speed = 20; // a nice starting speed, mixes well with a scale of 100
|
||||
// uint16_t speed = 33;
|
||||
// uint16_t speed = 100; // wicked fast!
|
||||
|
||||
// Scale determines how far apart the pixels in our noise matrix are. Try
|
||||
// changing these values around to see how it affects the motion of the display. The
|
||||
// higher the value of scale, the more "zoomed out" the noise iwll be. A value
|
||||
// of 1 will be so zoomed in, you'll mostly see solid colors.
|
||||
|
||||
// uint16_t scale = 1; // mostly just solid colors
|
||||
// uint16_t scale = 4011; // very zoomed out and shimmery
|
||||
uint16_t scale = 311;
|
||||
|
||||
// This is the array that we keep our computed noise values in
|
||||
uint8_t noise[MAX_DIMENSION][MAX_DIMENSION];
|
||||
|
||||
void setup() {
|
||||
// uncomment the following lines if you want to see FPS count information
|
||||
// Serial.begin(38400);
|
||||
// Serial.println("resetting!");
|
||||
delay(3000);
|
||||
LEDS.addLeds<WS2811,5,RGB>(leds,NUM_LEDS);
|
||||
LEDS.setBrightness(96);
|
||||
|
||||
// Initialize our coordinates to some random values
|
||||
x = random16();
|
||||
y = random16();
|
||||
z = random16();
|
||||
}
|
||||
|
||||
// Fill the x/y array of 8-bit noise values using the inoise8 function.
|
||||
void fillnoise8() {
|
||||
for(int i = 0; i < MAX_DIMENSION; i++) {
|
||||
int ioffset = scale * i;
|
||||
for(int j = 0; j < MAX_DIMENSION; j++) {
|
||||
int joffset = scale * j;
|
||||
noise[i][j] = inoise8(x + ioffset,y + joffset,z);
|
||||
}
|
||||
}
|
||||
z += speed;
|
||||
}
|
||||
|
||||
|
||||
void loop() {
|
||||
static uint8_t ihue=0;
|
||||
fillnoise8();
|
||||
for(int i = 0; i < kMatrixWidth; i++) {
|
||||
for(int j = 0; j < kMatrixHeight; j++) {
|
||||
// We use the value at the (i,j) coordinate in the noise
|
||||
// array for our brightness, and the flipped value from (j,i)
|
||||
// for our pixel's hue.
|
||||
leds[XY(i,j)] = CHSV(noise[j][i],255,noise[i][j]);
|
||||
|
||||
// You can also explore other ways to constrain the hue used, like below
|
||||
// leds[XY(i,j)] = CHSV(ihue + (noise[j][i]>>2),255,noise[i][j]);
|
||||
}
|
||||
}
|
||||
ihue+=1;
|
||||
|
||||
LEDS.show();
|
||||
// delay(10);
|
||||
}
|
@@ -0,0 +1,73 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define kMatrixWidth 16
|
||||
#define kMatrixHeight 16
|
||||
|
||||
#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
|
||||
// Param for different pixel layouts
|
||||
#define kMatrixSerpentineLayout true
|
||||
|
||||
// led array
|
||||
CRGB leds[kMatrixWidth * kMatrixHeight];
|
||||
|
||||
// x,y, & time values
|
||||
uint32_t x,y,v_time,hue_time,hxy;
|
||||
|
||||
// Play with the values of the variables below and see what kinds of effects they
|
||||
// have! More octaves will make things slower.
|
||||
|
||||
// how many octaves to use for the brightness and hue functions
|
||||
uint8_t octaves=1;
|
||||
uint8_t hue_octaves=3;
|
||||
|
||||
// the 'distance' between points on the x and y axis
|
||||
int xscale=57771;
|
||||
int yscale=57771;
|
||||
|
||||
// the 'distance' between x/y points for the hue noise
|
||||
int hue_scale=1;
|
||||
|
||||
// how fast we move through time & hue noise
|
||||
int time_speed=1111;
|
||||
int hue_speed=31;
|
||||
|
||||
// adjust these values to move along the x or y axis between frames
|
||||
int x_speed=331;
|
||||
int y_speed=1111;
|
||||
|
||||
void loop() {
|
||||
// fill the led array 2/16-bit noise values
|
||||
fill_2dnoise16(LEDS.leds(), kMatrixWidth, kMatrixHeight, kMatrixSerpentineLayout,
|
||||
octaves,x,xscale,y,yscale,v_time,
|
||||
hue_octaves,hxy,hue_scale,hxy,hue_scale,hue_time, false);
|
||||
|
||||
LEDS.show();
|
||||
|
||||
// adjust the intra-frame time values
|
||||
x += x_speed;
|
||||
y += y_speed;
|
||||
v_time += time_speed;
|
||||
hue_time += hue_speed;
|
||||
// delay(50);
|
||||
}
|
||||
|
||||
|
||||
void setup() {
|
||||
// initialize the x/y and time values
|
||||
random16_set_seed(8934);
|
||||
random16_add_entropy(analogRead(3));
|
||||
|
||||
Serial.begin(57600);
|
||||
Serial.println("resetting!");
|
||||
|
||||
delay(3000);
|
||||
LEDS.addLeds<WS2811,6,GRB>(leds,NUM_LEDS);
|
||||
LEDS.setBrightness(96);
|
||||
|
||||
hxy = (uint32_t)((uint32_t)random16() << 16) + (uint32_t)random16();
|
||||
x = (uint32_t)((uint32_t)random16() << 16) + (uint32_t)random16();
|
||||
y = (uint32_t)((uint32_t)random16() << 16) + (uint32_t)random16();
|
||||
v_time = (uint32_t)((uint32_t)random16() << 16) + (uint32_t)random16();
|
||||
hue_time = (uint32_t)((uint32_t)random16() << 16) + (uint32_t)random16();
|
||||
|
||||
}
|
@@ -0,0 +1,273 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define LED_PIN 3
|
||||
#define BRIGHTNESS 96
|
||||
#define LED_TYPE WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
|
||||
const uint8_t kMatrixWidth = 16;
|
||||
const uint8_t kMatrixHeight = 16;
|
||||
const bool kMatrixSerpentineLayout = true;
|
||||
|
||||
|
||||
// This example combines two features of FastLED to produce a remarkable range of
|
||||
// effects from a relatively small amount of code. This example combines FastLED's
|
||||
// color palette lookup functions with FastLED's Perlin/simplex noise generator, and
|
||||
// the combination is extremely powerful.
|
||||
//
|
||||
// You might want to look at the "ColorPalette" and "Noise" examples separately
|
||||
// if this example code seems daunting.
|
||||
//
|
||||
//
|
||||
// The basic setup here is that for each frame, we generate a new array of
|
||||
// 'noise' data, and then map it onto the LED matrix through a color palette.
|
||||
//
|
||||
// Periodically, the color palette is changed, and new noise-generation parameters
|
||||
// are chosen at the same time. In this example, specific noise-generation
|
||||
// values have been selected to match the given color palettes; some are faster,
|
||||
// or slower, or larger, or smaller than others, but there's no reason these
|
||||
// parameters can't be freely mixed-and-matched.
|
||||
//
|
||||
// In addition, this example includes some fast automatic 'data smoothing' at
|
||||
// lower noise speeds to help produce smoother animations in those cases.
|
||||
//
|
||||
// The FastLED built-in color palettes (Forest, Clouds, Lava, Ocean, Party) are
|
||||
// used, as well as some 'hand-defined' ones, and some proceedurally generated
|
||||
// palettes.
|
||||
|
||||
|
||||
#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
|
||||
#define MAX_DIMENSION ((kMatrixWidth>kMatrixHeight) ? kMatrixWidth : kMatrixHeight)
|
||||
|
||||
// The leds
|
||||
CRGB leds[kMatrixWidth * kMatrixHeight];
|
||||
|
||||
// The 16 bit version of our coordinates
|
||||
static uint16_t x;
|
||||
static uint16_t y;
|
||||
static uint16_t z;
|
||||
|
||||
// We're using the x/y dimensions to map to the x/y pixels on the matrix. We'll
|
||||
// use the z-axis for "time". speed determines how fast time moves forward. Try
|
||||
// 1 for a very slow moving effect, or 60 for something that ends up looking like
|
||||
// water.
|
||||
uint16_t speed = 20; // speed is set dynamically once we've started up
|
||||
|
||||
// Scale determines how far apart the pixels in our noise matrix are. Try
|
||||
// changing these values around to see how it affects the motion of the display. The
|
||||
// higher the value of scale, the more "zoomed out" the noise iwll be. A value
|
||||
// of 1 will be so zoomed in, you'll mostly see solid colors.
|
||||
uint16_t scale = 30; // scale is set dynamically once we've started up
|
||||
|
||||
// This is the array that we keep our computed noise values in
|
||||
uint8_t noise[MAX_DIMENSION][MAX_DIMENSION];
|
||||
|
||||
CRGBPalette16 currentPalette( PartyColors_p );
|
||||
uint8_t colorLoop = 1;
|
||||
|
||||
void setup() {
|
||||
delay(3000);
|
||||
LEDS.addLeds<LED_TYPE,LED_PIN,COLOR_ORDER>(leds,NUM_LEDS);
|
||||
LEDS.setBrightness(BRIGHTNESS);
|
||||
|
||||
// Initialize our coordinates to some random values
|
||||
x = random16();
|
||||
y = random16();
|
||||
z = random16();
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Fill the x/y array of 8-bit noise values using the inoise8 function.
|
||||
void fillnoise8() {
|
||||
// If we're runing at a low "speed", some 8-bit artifacts become visible
|
||||
// from frame-to-frame. In order to reduce this, we can do some fast data-smoothing.
|
||||
// The amount of data smoothing we're doing depends on "speed".
|
||||
uint8_t dataSmoothing = 0;
|
||||
if( speed < 50) {
|
||||
dataSmoothing = 200 - (speed * 4);
|
||||
}
|
||||
|
||||
for(int i = 0; i < MAX_DIMENSION; i++) {
|
||||
int ioffset = scale * i;
|
||||
for(int j = 0; j < MAX_DIMENSION; j++) {
|
||||
int joffset = scale * j;
|
||||
|
||||
uint8_t data = inoise8(x + ioffset,y + joffset,z);
|
||||
|
||||
// The range of the inoise8 function is roughly 16-238.
|
||||
// These two operations expand those values out to roughly 0..255
|
||||
// You can comment them out if you want the raw noise data.
|
||||
data = qsub8(data,16);
|
||||
data = qadd8(data,scale8(data,39));
|
||||
|
||||
if( dataSmoothing ) {
|
||||
uint8_t olddata = noise[i][j];
|
||||
uint8_t newdata = scale8( olddata, dataSmoothing) + scale8( data, 256 - dataSmoothing);
|
||||
data = newdata;
|
||||
}
|
||||
|
||||
noise[i][j] = data;
|
||||
}
|
||||
}
|
||||
|
||||
z += speed;
|
||||
|
||||
// apply slow drift to X and Y, just for visual variation.
|
||||
x += speed / 8;
|
||||
y -= speed / 16;
|
||||
}
|
||||
|
||||
void mapNoiseToLEDsUsingPalette()
|
||||
{
|
||||
static uint8_t ihue=0;
|
||||
|
||||
for(int i = 0; i < kMatrixWidth; i++) {
|
||||
for(int j = 0; j < kMatrixHeight; j++) {
|
||||
// We use the value at the (i,j) coordinate in the noise
|
||||
// array for our brightness, and the flipped value from (j,i)
|
||||
// for our pixel's index into the color palette.
|
||||
|
||||
uint8_t index = noise[j][i];
|
||||
uint8_t bri = noise[i][j];
|
||||
|
||||
// if this palette is a 'loop', add a slowly-changing base value
|
||||
if( colorLoop) {
|
||||
index += ihue;
|
||||
}
|
||||
|
||||
// brighten up, as the color palette itself often contains the
|
||||
// light/dark dynamic range desired
|
||||
if( bri > 127 ) {
|
||||
bri = 255;
|
||||
} else {
|
||||
bri = dim8_raw( bri * 2);
|
||||
}
|
||||
|
||||
CRGB color = ColorFromPalette( currentPalette, index, bri);
|
||||
leds[XY(i,j)] = color;
|
||||
}
|
||||
}
|
||||
|
||||
ihue+=1;
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Periodically choose a new palette, speed, and scale
|
||||
ChangePaletteAndSettingsPeriodically();
|
||||
|
||||
// generate noise data
|
||||
fillnoise8();
|
||||
|
||||
// convert the noise data to colors in the LED array
|
||||
// using the current palette
|
||||
mapNoiseToLEDsUsingPalette();
|
||||
|
||||
LEDS.show();
|
||||
// delay(10);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 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.
|
||||
|
||||
// 1 = 5 sec per palette
|
||||
// 2 = 10 sec per palette
|
||||
// etc
|
||||
#define HOLD_PALETTES_X_TIMES_AS_LONG 1
|
||||
|
||||
void ChangePaletteAndSettingsPeriodically()
|
||||
{
|
||||
uint8_t secondHand = ((millis() / 1000) / HOLD_PALETTES_X_TIMES_AS_LONG) % 60;
|
||||
static uint8_t lastSecond = 99;
|
||||
|
||||
if( lastSecond != secondHand) {
|
||||
lastSecond = secondHand;
|
||||
if( secondHand == 0) { currentPalette = RainbowColors_p; speed = 20; scale = 30; colorLoop = 1; }
|
||||
if( secondHand == 5) { SetupPurpleAndGreenPalette(); speed = 10; scale = 50; colorLoop = 1; }
|
||||
if( secondHand == 10) { SetupBlackAndWhiteStripedPalette(); speed = 20; scale = 30; colorLoop = 1; }
|
||||
if( secondHand == 15) { currentPalette = ForestColors_p; speed = 8; scale =120; colorLoop = 0; }
|
||||
if( secondHand == 20) { currentPalette = CloudColors_p; speed = 4; scale = 30; colorLoop = 0; }
|
||||
if( secondHand == 25) { currentPalette = LavaColors_p; speed = 8; scale = 50; colorLoop = 0; }
|
||||
if( secondHand == 30) { currentPalette = OceanColors_p; speed = 20; scale = 90; colorLoop = 0; }
|
||||
if( secondHand == 35) { currentPalette = PartyColors_p; speed = 20; scale = 30; colorLoop = 1; }
|
||||
if( secondHand == 40) { SetupRandomPalette(); speed = 20; scale = 20; colorLoop = 1; }
|
||||
if( secondHand == 45) { SetupRandomPalette(); speed = 50; scale = 50; colorLoop = 1; }
|
||||
if( secondHand == 50) { SetupRandomPalette(); speed = 90; scale = 90; colorLoop = 1; }
|
||||
if( secondHand == 55) { currentPalette = RainbowStripeColors_p; speed = 30; scale = 20; colorLoop = 1; }
|
||||
}
|
||||
}
|
||||
|
||||
// This function generates a random palette that's a gradient
|
||||
// between four different colors. The first is a dim hue, the second is
|
||||
// a bright hue, the third is a bright pastel, and the last is
|
||||
// another bright hue. This gives some visual bright/dark variation
|
||||
// which is more interesting than just a gradient of different hues.
|
||||
void SetupRandomPalette()
|
||||
{
|
||||
currentPalette = CRGBPalette16(
|
||||
CHSV( random8(), 255, 32),
|
||||
CHSV( random8(), 255, 255),
|
||||
CHSV( random8(), 128, 255),
|
||||
CHSV( random8(), 255, 255));
|
||||
}
|
||||
|
||||
// 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 );
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Mark's xy coordinate mapping code. See the XYMatrix for more information on it.
|
||||
//
|
||||
uint16_t XY( uint8_t x, uint8_t y)
|
||||
{
|
||||
uint16_t i;
|
||||
if( kMatrixSerpentineLayout == false) {
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
if( kMatrixSerpentineLayout == true) {
|
||||
if( y & 0x01) {
|
||||
// Odd rows run backwards
|
||||
uint8_t reverseX = (kMatrixWidth - 1) - x;
|
||||
i = (y * kMatrixWidth) + reverseX;
|
||||
} else {
|
||||
// Even rows run forwards
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
152
libraries/FastLED-3.4.0/examples/Pacifica/Pacifica.ino
Normal file
152
libraries/FastLED-3.4.0/examples/Pacifica/Pacifica.ino
Normal file
@@ -0,0 +1,152 @@
|
||||
//
|
||||
// "Pacifica"
|
||||
// Gentle, blue-green ocean waves.
|
||||
// December 2019, Mark Kriegsman and Mary Corey March.
|
||||
// For Dan.
|
||||
//
|
||||
|
||||
#define FASTLED_ALLOW_INTERRUPTS 0
|
||||
#include <FastLED.h>
|
||||
FASTLED_USING_NAMESPACE
|
||||
|
||||
#define DATA_PIN 3
|
||||
#define NUM_LEDS 60
|
||||
#define MAX_POWER_MILLIAMPS 500
|
||||
#define LED_TYPE WS2812B
|
||||
#define COLOR_ORDER GRB
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
void setup() {
|
||||
delay( 3000); // 3 second delay for boot recovery, and a moment of silence
|
||||
FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS)
|
||||
.setCorrection( TypicalLEDStrip );
|
||||
FastLED.setMaxPowerInVoltsAndMilliamps( 5, MAX_POWER_MILLIAMPS);
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
EVERY_N_MILLISECONDS( 20) {
|
||||
pacifica_loop();
|
||||
FastLED.show();
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// The code for this animation is more complicated than other examples, and
|
||||
// while it is "ready to run", and documented in general, it is probably not
|
||||
// the best starting point for learning. Nevertheless, it does illustrate some
|
||||
// useful techniques.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// In this animation, there are four "layers" of waves of light.
|
||||
//
|
||||
// Each layer moves independently, and each is scaled separately.
|
||||
//
|
||||
// All four wave layers are added together on top of each other, and then
|
||||
// another filter is applied that adds "whitecaps" of brightness where the
|
||||
// waves line up with each other more. Finally, another pass is taken
|
||||
// over the led array to 'deepen' (dim) the blues and greens.
|
||||
//
|
||||
// The speed and scale and motion each layer varies slowly within independent
|
||||
// hand-chosen ranges, which is why the code has a lot of low-speed 'beatsin8' functions
|
||||
// with a lot of oddly specific numeric ranges.
|
||||
//
|
||||
// These three custom blue-green color palettes were inspired by the colors found in
|
||||
// the waters off the southern coast of California, https://goo.gl/maps/QQgd97jjHesHZVxQ7
|
||||
//
|
||||
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 };
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
199
libraries/FastLED-3.4.0/examples/Pintest/Pintest.ino
Normal file
199
libraries/FastLED-3.4.0/examples/Pintest/Pintest.ino
Normal file
@@ -0,0 +1,199 @@
|
||||
|
||||
#include <FastLED.h>
|
||||
|
||||
char fullstrBuffer[64];
|
||||
|
||||
const char *getPort(void *portPtr) {
|
||||
// AVR port checks
|
||||
#ifdef PORTA
|
||||
if(portPtr == (void*)&PORTA) { return "PORTA"; }
|
||||
#endif
|
||||
#ifdef PORTB
|
||||
if(portPtr == (void*)&PORTB) { return "PORTB"; }
|
||||
#endif
|
||||
#ifdef PORTC
|
||||
if(portPtr == (void*)&PORTC) { return "PORTC"; }
|
||||
#endif
|
||||
#ifdef PORTD
|
||||
if(portPtr == (void*)&PORTD) { return "PORTD"; }
|
||||
#endif
|
||||
#ifdef PORTE
|
||||
if(portPtr == (void*)&PORTE) { return "PORTE"; }
|
||||
#endif
|
||||
#ifdef PORTF
|
||||
if(portPtr == (void*)&PORTF) { return "PORTF"; }
|
||||
#endif
|
||||
#ifdef PORTG
|
||||
if(portPtr == (void*)&PORTG) { return "PORTG"; }
|
||||
#endif
|
||||
#ifdef PORTH
|
||||
if(portPtr == (void*)&PORTH) { return "PORTH"; }
|
||||
#endif
|
||||
#ifdef PORTI
|
||||
if(portPtr == (void*)&PORTI) { return "PORTI"; }
|
||||
#endif
|
||||
#ifdef PORTJ
|
||||
if(portPtr == (void*)&PORTJ) { return "PORTJ"; }
|
||||
#endif
|
||||
#ifdef PORTK
|
||||
if(portPtr == (void*)&PORTK) { return "PORTK"; }
|
||||
#endif
|
||||
#ifdef PORTL
|
||||
if(portPtr == (void*)&PORTL) { return "PORTL"; }
|
||||
#endif
|
||||
|
||||
// Teensy 3.x port checks
|
||||
#ifdef GPIO_A_PDOR
|
||||
if(portPtr == (void*)&GPIO_A_PDOR) { return "GPIO_A_PDOR"; }
|
||||
#endif
|
||||
#ifdef GPIO_B_PDOR
|
||||
if(portPtr == (void*)&GPIO_B_PDOR) { return "GPIO_B_PDOR"; }
|
||||
#endif
|
||||
#ifdef GPIO_C_PDOR
|
||||
if(portPtr == (void*)&GPIO_C_PDOR) { return "GPIO_C_PDOR"; }
|
||||
#endif
|
||||
#ifdef GPIO_D_PDOR
|
||||
if(portPtr == (void*)&GPIO_D_PDOR) { return "GPIO_D_PDOR"; }
|
||||
#endif
|
||||
#ifdef GPIO_E_PDOR
|
||||
if(portPtr == (void*)&GPIO_E_PDOR) { return "GPIO_E_PDOR"; }
|
||||
#endif
|
||||
#ifdef REG_PIO_A_ODSR
|
||||
if(portPtr == (void*)®_PIO_A_ODSR) { return "REG_PIO_A_ODSR"; }
|
||||
#endif
|
||||
#ifdef REG_PIO_B_ODSR
|
||||
if(portPtr == (void*)®_PIO_B_ODSR) { return "REG_PIO_B_ODSR"; }
|
||||
#endif
|
||||
#ifdef REG_PIO_C_ODSR
|
||||
if(portPtr == (void*)®_PIO_C_ODSR) { return "REG_PIO_C_ODSR"; }
|
||||
#endif
|
||||
#ifdef REG_PIO_D_ODSR
|
||||
if(portPtr == (void*)®_PIO_D_ODSR) { return "REG_PIO_D_ODSR"; }
|
||||
#endif
|
||||
|
||||
// Teensy 4 port checks
|
||||
#ifdef GPIO1_DR
|
||||
if(portPtr == (void*)&GPIO1_DR) { return "GPIO1_DR"; }
|
||||
#endif
|
||||
#ifdef GPIO2_DR
|
||||
if(portPtr == (void*)&GPIO2_DR) { return "GPIO21_DR"; }
|
||||
#endif
|
||||
#ifdef GPIO3_DR
|
||||
if(portPtr == (void*)&GPIO3_DR) { return "GPIO3_DR"; }
|
||||
#endif
|
||||
#ifdef GPIO4_DR
|
||||
if(portPtr == (void*)&GPIO4_DR) { return "GPIO4_DR"; }
|
||||
#endif
|
||||
String unknown_str = "Unknown: " + String((size_t)portPtr, HEX);
|
||||
strncpy(fullstrBuffer, unknown_str.c_str(), unknown_str.length());
|
||||
fullstrBuffer[sizeof(fullstrBuffer)-1] = '\0';
|
||||
return fullstrBuffer;
|
||||
}
|
||||
|
||||
template<uint8_t PIN> void CheckPin()
|
||||
{
|
||||
CheckPin<PIN - 1>();
|
||||
|
||||
void *systemThinksPortIs = (void*)portOutputRegister(digitalPinToPort(PIN));
|
||||
RwReg systemThinksMaskIs = digitalPinToBitMask(PIN);
|
||||
|
||||
Serial.print("Pin "); Serial.print(PIN); Serial.print(": Port ");
|
||||
|
||||
if(systemThinksPortIs == (void*)FastPin<PIN>::port()) {
|
||||
Serial.print("valid & mask ");
|
||||
} else {
|
||||
Serial.print("invalid, is "); Serial.print(getPort((void*)FastPin<PIN>::port())); Serial.print(" should be ");
|
||||
Serial.print(getPort((void*)systemThinksPortIs));
|
||||
Serial.print(" & mask ");
|
||||
}
|
||||
|
||||
if(systemThinksMaskIs == FastPin<PIN>::mask()) {
|
||||
Serial.println("valid.");
|
||||
} else {
|
||||
Serial.print("invalid, is "); Serial.print(FastPin<PIN>::mask()); Serial.print(" should be "); Serial.println(systemThinksMaskIs);
|
||||
}
|
||||
}
|
||||
|
||||
template<> void CheckPin<255> () {}
|
||||
|
||||
|
||||
template<uint8_t _PORT> const char *_GetPinPort(void *ptr) {
|
||||
if (__FL_PORT_INFO<_PORT>::hasPort() && (ptr == (void*)__FL_PORT_INFO<_PORT>::portAddr())) {
|
||||
return __FL_PORT_INFO<_PORT>::portName();
|
||||
} else {
|
||||
return _GetPinPort<_PORT - 1>(ptr);
|
||||
}
|
||||
}
|
||||
template<> const char *_GetPinPort<-1>(void *ptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char *GetPinPort(void *ptr) {
|
||||
return _GetPinPort<'Z'>(ptr);
|
||||
}
|
||||
|
||||
static uint8_t pcount = 0;
|
||||
|
||||
|
||||
template<uint8_t PIN> void PrintPins() {
|
||||
PrintPins<PIN - 1>();
|
||||
|
||||
RwReg *systemThinksPortIs = portOutputRegister(digitalPinToPort(PIN));
|
||||
RwReg systemThinksMaskIs = digitalPinToBitMask(PIN);
|
||||
|
||||
int maskBit = 0;
|
||||
while(systemThinksMaskIs > 1) { systemThinksMaskIs >>= 1; maskBit++; }
|
||||
|
||||
const char *pinport = GetPinPort((void*)systemThinksPortIs);
|
||||
if (pinport) {
|
||||
Serial.print("__FL_DEFPIN("); Serial.print(PIN);
|
||||
Serial.print(","); Serial.print(maskBit);
|
||||
Serial.print(","); Serial.print(pinport);
|
||||
Serial.print("); ");
|
||||
pcount++;
|
||||
if(pcount == 4) { pcount = 0; Serial.println(""); }
|
||||
} else {
|
||||
// Serial.print("Not found for pin "); Serial.println(PIN);
|
||||
}
|
||||
}
|
||||
|
||||
template<> void PrintPins<0>() {
|
||||
RwReg *systemThinksPortIs = portOutputRegister(digitalPinToPort(0));
|
||||
RwReg systemThinksMaskIs = digitalPinToBitMask(0);
|
||||
|
||||
int maskBit = 0;
|
||||
while(systemThinksMaskIs > 1) { systemThinksMaskIs >>= 1; maskBit++; }
|
||||
|
||||
const char *pinport = GetPinPort((void*)systemThinksPortIs);
|
||||
if (pinport) {
|
||||
Serial.print("__FL_DEFPIN("); Serial.print(0);
|
||||
Serial.print(","); Serial.print(maskBit);
|
||||
Serial.print(","); Serial.print(pinport);
|
||||
Serial.print("); ");
|
||||
pcount++;
|
||||
if(pcount == 4) { pcount = 0; Serial.println(""); }
|
||||
}
|
||||
}
|
||||
|
||||
int counter = 0;
|
||||
void setup() {
|
||||
delay(5000);
|
||||
Serial.begin(38400);
|
||||
Serial.println("resetting!");
|
||||
}
|
||||
|
||||
void loop() {
|
||||
Serial.println(counter);
|
||||
|
||||
#ifdef MAX_PIN
|
||||
CheckPin<MAX_PIN>();
|
||||
#endif
|
||||
|
||||
Serial.println("-----");
|
||||
#ifdef NUM_DIGITAL_PINS
|
||||
PrintPins<NUM_DIGITAL_PINS>();
|
||||
#endif
|
||||
Serial.println("------");
|
||||
|
||||
delay(100000);
|
||||
}
|
@@ -0,0 +1,136 @@
|
||||
// LED Audio Spectrum Analyzer Display
|
||||
//
|
||||
// Creates an impressive LED light show to music input
|
||||
// using Teensy 3.1 with the OctoWS2811 adaptor board
|
||||
// http://www.pjrc.com/store/teensy31.html
|
||||
// http://www.pjrc.com/store/octo28_adaptor.html
|
||||
//
|
||||
// Line Level Audio Input connects to analog pin A3
|
||||
// Recommended input circuit:
|
||||
// http://www.pjrc.com/teensy/gui/?info=AudioInputAnalog
|
||||
//
|
||||
// This example code is in the public domain.
|
||||
|
||||
#define USE_OCTOWS2811
|
||||
#include <OctoWS2811.h>
|
||||
#include <FastLED.h>
|
||||
#include <Audio.h>
|
||||
#include <Wire.h>
|
||||
#include <SD.h>
|
||||
#include <SPI.h>
|
||||
|
||||
// The display size and color to use
|
||||
const unsigned int matrix_width = 60;
|
||||
const unsigned int matrix_height = 32;
|
||||
const unsigned int myColor = 0x400020;
|
||||
|
||||
// These parameters adjust the vertical thresholds
|
||||
const float maxLevel = 0.5; // 1.0 = max, lower is more "sensitive"
|
||||
const float dynamicRange = 40.0; // total range to display, in decibels
|
||||
const float linearBlend = 0.3; // useful range is 0 to 0.7
|
||||
|
||||
CRGB leds[matrix_width * matrix_height];
|
||||
|
||||
// Audio library objects
|
||||
AudioInputAnalog adc1(A3); //xy=99,55
|
||||
AudioAnalyzeFFT1024 fft; //xy=265,75
|
||||
AudioConnection patchCord1(adc1, fft);
|
||||
|
||||
|
||||
// This array holds the volume level (0 to 1.0) for each
|
||||
// vertical pixel to turn on. Computed in setup() using
|
||||
// the 3 parameters above.
|
||||
float thresholdVertical[matrix_height];
|
||||
|
||||
// This array specifies how many of the FFT frequency bin
|
||||
// to use for each horizontal pixel. Because humans hear
|
||||
// in octaves and FFT bins are linear, the low frequencies
|
||||
// use a small number of bins, higher frequencies use more.
|
||||
int frequencyBinsHorizontal[matrix_width] = {
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
|
||||
3, 3, 3, 3, 4, 4, 4, 4, 4, 5,
|
||||
5, 5, 6, 6, 6, 7, 7, 7, 8, 8,
|
||||
9, 9, 10, 10, 11, 12, 12, 13, 14, 15,
|
||||
15, 16, 17, 18, 19, 20, 22, 23, 24, 25
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Run setup once
|
||||
void setup() {
|
||||
// the audio library needs to be given memory to start working
|
||||
AudioMemory(12);
|
||||
|
||||
// compute the vertical thresholds before starting
|
||||
computeVerticalLevels();
|
||||
|
||||
// turn on the display
|
||||
FastLED.addLeds<OCTOWS2811>(leds,(matrix_width * matrix_height) / 8);
|
||||
}
|
||||
|
||||
// A simple xy() function to turn display matrix coordinates
|
||||
// into the index numbers OctoWS2811 requires. If your LEDs
|
||||
// are arranged differently, edit this code...
|
||||
unsigned int xy(unsigned int x, unsigned int y) {
|
||||
if ((y & 1) == 0) {
|
||||
// even numbered rows (0, 2, 4...) are left to right
|
||||
return y * matrix_width + x;
|
||||
} else {
|
||||
// odd numbered rows (1, 3, 5...) are right to left
|
||||
return y * matrix_width + matrix_width - 1 - x;
|
||||
}
|
||||
}
|
||||
|
||||
// Run repetitively
|
||||
void loop() {
|
||||
unsigned int x, y, freqBin;
|
||||
float level;
|
||||
|
||||
if (fft.available()) {
|
||||
// freqBin counts which FFT frequency data has been used,
|
||||
// starting at low frequency
|
||||
freqBin = 0;
|
||||
|
||||
for (x=0; x < matrix_width; x++) {
|
||||
// get the volume for each horizontal pixel position
|
||||
level = fft.read(freqBin, freqBin + frequencyBinsHorizontal[x] - 1);
|
||||
|
||||
// uncomment to see the spectrum in Arduino's Serial Monitor
|
||||
// Serial.print(level);
|
||||
// Serial.print(" ");
|
||||
|
||||
for (y=0; y < matrix_height; y++) {
|
||||
// for each vertical pixel, check if above the threshold
|
||||
// and turn the LED on or off
|
||||
if (level >= thresholdVertical[y]) {
|
||||
leds[xy(x,y)] = CRGB(myColor);
|
||||
} else {
|
||||
leds[xy(x,y)] = CRGB::Black;
|
||||
}
|
||||
}
|
||||
// increment the frequency bin count, so we display
|
||||
// low to higher frequency from left to right
|
||||
freqBin = freqBin + frequencyBinsHorizontal[x];
|
||||
}
|
||||
// after all pixels set, show them all at the same instant
|
||||
FastLED.show();
|
||||
// Serial.println();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Run once from setup, the compute the vertical levels
|
||||
void computeVerticalLevels() {
|
||||
unsigned int y;
|
||||
float n, logLevel, linearLevel;
|
||||
|
||||
for (y=0; y < matrix_height; y++) {
|
||||
n = (float)y / (float)(matrix_height - 1);
|
||||
logLevel = pow10f(n * -1.0 * (dynamicRange / 20.0));
|
||||
linearLevel = 1.0 - n;
|
||||
linearLevel = linearLevel * linearBlend;
|
||||
logLevel = logLevel * (1.0 - linearBlend);
|
||||
thresholdVertical[y] = (logLevel + linearLevel) * maxLevel;
|
||||
}
|
||||
}
|
82
libraries/FastLED-3.4.0/examples/Pride2015/Pride2015.ino
Normal file
82
libraries/FastLED-3.4.0/examples/Pride2015/Pride2015.ino
Normal file
@@ -0,0 +1,82 @@
|
||||
#include "FastLED.h"
|
||||
|
||||
// Pride2015
|
||||
// Animated, ever-changing rainbows.
|
||||
// by Mark Kriegsman
|
||||
|
||||
#if FASTLED_VERSION < 3001000
|
||||
#error "Requires FastLED 3.1 or later; check github for latest code."
|
||||
#endif
|
||||
|
||||
#define DATA_PIN 3
|
||||
//#define CLK_PIN 4
|
||||
#define LED_TYPE WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
#define NUM_LEDS 200
|
||||
#define BRIGHTNESS 255
|
||||
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
|
||||
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)
|
||||
.setDither(BRIGHTNESS < 255);
|
||||
|
||||
// set master brightness control
|
||||
FastLED.setBrightness(BRIGHTNESS);
|
||||
}
|
||||
|
||||
|
||||
void loop()
|
||||
{
|
||||
pride();
|
||||
FastLED.show();
|
||||
}
|
||||
|
||||
|
||||
// This function draws rainbows with an ever-changing,
|
||||
// widely-varying set of parameters.
|
||||
void pride()
|
||||
{
|
||||
static uint16_t sPseudotime = 0;
|
||||
static uint16_t sLastMillis = 0;
|
||||
static uint16_t sHue16 = 0;
|
||||
|
||||
uint8_t sat8 = beatsin88( 87, 220, 250);
|
||||
uint8_t brightdepth = beatsin88( 341, 96, 224);
|
||||
uint16_t brightnessthetainc16 = beatsin88( 203, (25 * 256), (40 * 256));
|
||||
uint8_t msmultiplier = beatsin88(147, 23, 60);
|
||||
|
||||
uint16_t hue16 = sHue16;//gHue * 256;
|
||||
uint16_t hueinc16 = beatsin88(113, 1, 3000);
|
||||
|
||||
uint16_t ms = millis();
|
||||
uint16_t deltams = ms - sLastMillis ;
|
||||
sLastMillis = ms;
|
||||
sPseudotime += deltams * msmultiplier;
|
||||
sHue16 += deltams * beatsin88( 400, 5,9);
|
||||
uint16_t brightnesstheta16 = sPseudotime;
|
||||
|
||||
for( uint16_t i = 0 ; i < NUM_LEDS; i++) {
|
||||
hue16 += hueinc16;
|
||||
uint8_t hue8 = hue16 / 256;
|
||||
|
||||
brightnesstheta16 += brightnessthetainc16;
|
||||
uint16_t b16 = sin16( brightnesstheta16 ) + 32768;
|
||||
|
||||
uint16_t bri16 = (uint32_t)((uint32_t)b16 * (uint32_t)b16) / 65536;
|
||||
uint8_t bri8 = (uint32_t)(((uint32_t)bri16) * brightdepth) / 65536;
|
||||
bri8 += (255 - brightdepth);
|
||||
|
||||
CRGB newcolor = CHSV( hue8, sat8, bri8);
|
||||
|
||||
uint16_t pixelnumber = i;
|
||||
pixelnumber = (NUM_LEDS-1) - pixelnumber;
|
||||
|
||||
nblend( leds[pixelnumber], newcolor, 64);
|
||||
}
|
||||
}
|
@@ -0,0 +1,95 @@
|
||||
#include "FastLED.h"
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// RGB Calibration code
|
||||
//
|
||||
// Use this sketch to determine what the RGB ordering for your chipset should be. Steps for setting up to use:
|
||||
|
||||
// * Uncomment the line in setup that corresponds to the LED chipset that you are using. (Note that they
|
||||
// all explicitly specify the RGB order as RGB)
|
||||
// * Define DATA_PIN to the pin that data is connected to.
|
||||
// * (Optional) if using software SPI for chipsets that are SPI based, define CLOCK_PIN to the clock pin
|
||||
// * Compile/upload/run the sketch
|
||||
|
||||
// You should see six leds on. If the RGB ordering is correct, you should see 1 red led, 2 green
|
||||
// leds, and 3 blue leds. If you see different colors, the count of each color tells you what the
|
||||
// position for that color in the rgb orering should be. So, for example, if you see 1 Blue, and 2
|
||||
// Red, and 3 Green leds then the rgb ordering should be BRG (Blue, Red, Green).
|
||||
|
||||
// You can then test this ordering by setting the RGB ordering in the addLeds line below to the new ordering
|
||||
// and it should come out correctly, 1 red, 2 green, and 3 blue.
|
||||
//
|
||||
//////////////////////////////////////////////////
|
||||
|
||||
#define NUM_LEDS 7
|
||||
|
||||
// For led chips like WS2812, which have a data line, ground, and power, you just
|
||||
// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,
|
||||
// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN
|
||||
// Clock pin only needed for SPI based chipsets when not using hardware SPI
|
||||
#define DATA_PIN 3
|
||||
#define CLOCK_PIN 13
|
||||
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
void setup() {
|
||||
// sanity check delay - allows reprogramming if accidently blowing power w/leds
|
||||
delay(2000);
|
||||
|
||||
// Uncomment/edit one of the following lines for your leds arrangement.
|
||||
// ## Clockless types ##
|
||||
// FastLED.addLeds<SM16703, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1829, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1812, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1903B, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS1904, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<UCS2903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2852, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<GS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SK6812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<APA106, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<PL9823, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2813, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<APA104, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2811_400, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GE8822, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GW6205, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<GW6205_400, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<LPD1886, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<LPD1886_8BIT, DATA_PIN, RGB>(leds, NUM_LEDS);
|
||||
// ## Clocked (SPI) types ##
|
||||
// FastLED.addLeds<LPD6803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical
|
||||
// FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<WS2803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
|
||||
// FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
// FastLED.addLeds<SK9822, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical
|
||||
|
||||
// FastLED.setBrightness(CRGB(255,255,255));
|
||||
}
|
||||
|
||||
void loop() {
|
||||
leds[0] = CRGB(255,0,0);
|
||||
leds[1] = CRGB(0,255,0);
|
||||
leds[2] = CRGB(0,255,0);
|
||||
leds[3] = CRGB(0,0,255);
|
||||
leds[4] = CRGB(0,0,255);
|
||||
leds[5] = CRGB(0,0,255);
|
||||
leds[6] = CRGB(0,0,0);
|
||||
FastLED.show();
|
||||
delay(1000);
|
||||
}
|
22
libraries/FastLED-3.4.0/examples/RGBSetDemo/RGBSetDemo.ino
Normal file
22
libraries/FastLED-3.4.0/examples/RGBSetDemo/RGBSetDemo.ino
Normal file
@@ -0,0 +1,22 @@
|
||||
#include <FastLED.h>
|
||||
#define NUM_LEDS 40
|
||||
|
||||
CRGBArray<NUM_LEDS> leds;
|
||||
|
||||
void setup() { FastLED.addLeds<NEOPIXEL,6>(leds, NUM_LEDS); }
|
||||
|
||||
void loop(){
|
||||
static uint8_t hue;
|
||||
for(int i = 0; i < NUM_LEDS/2; i++) {
|
||||
// fade everything out
|
||||
leds.fadeToBlackBy(40);
|
||||
|
||||
// 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(33);
|
||||
}
|
||||
}
|
||||
|
121
libraries/FastLED-3.4.0/examples/SmartMatrix/SmartMatrix.ino
Normal file
121
libraries/FastLED-3.4.0/examples/SmartMatrix/SmartMatrix.ino
Normal file
@@ -0,0 +1,121 @@
|
||||
#include <SmartMatrix.h>
|
||||
#include <FastLED.h>
|
||||
|
||||
#define kMatrixWidth 32
|
||||
#define kMatrixHeight 32
|
||||
const bool kMatrixSerpentineLayout = false;
|
||||
|
||||
#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
|
||||
|
||||
CRGB leds[kMatrixWidth * kMatrixHeight];
|
||||
|
||||
|
||||
uint16_t XY( uint8_t x, uint8_t y)
|
||||
{
|
||||
uint16_t i;
|
||||
|
||||
if( kMatrixSerpentineLayout == false) {
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
|
||||
if( kMatrixSerpentineLayout == true) {
|
||||
if( y & 0x01) {
|
||||
// Odd rows run backwards
|
||||
uint8_t reverseX = (kMatrixWidth - 1) - x;
|
||||
i = (y * kMatrixWidth) + reverseX;
|
||||
} else {
|
||||
// Even rows run forwards
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
// The 32bit version of our coordinates
|
||||
static uint16_t x;
|
||||
static uint16_t y;
|
||||
static uint16_t z;
|
||||
|
||||
// We're using the x/y dimensions to map to the x/y pixels on the matrix. We'll
|
||||
// use the z-axis for "time". speed determines how fast time moves forward. Try
|
||||
// 1 for a very slow moving effect, or 60 for something that ends up looking like
|
||||
// water.
|
||||
// uint16_t speed = 1; // almost looks like a painting, moves very slowly
|
||||
uint16_t speed = 20; // a nice starting speed, mixes well with a scale of 100
|
||||
// uint16_t speed = 33;
|
||||
// uint16_t speed = 100; // wicked fast!
|
||||
|
||||
// Scale determines how far apart the pixels in our noise matrix are. Try
|
||||
// changing these values around to see how it affects the motion of the display. The
|
||||
// higher the value of scale, the more "zoomed out" the noise iwll be. A value
|
||||
// of 1 will be so zoomed in, you'll mostly see solid colors.
|
||||
|
||||
// uint16_t scale = 1; // mostly just solid colors
|
||||
// uint16_t scale = 4011; // very zoomed out and shimmery
|
||||
uint16_t scale = 31;
|
||||
|
||||
// This is the array that we keep our computed noise values in
|
||||
uint8_t noise[kMatrixWidth][kMatrixHeight];
|
||||
|
||||
void setup() {
|
||||
// uncomment the following lines if you want to see FPS count information
|
||||
// Serial.begin(38400);
|
||||
// Serial.println("resetting!");
|
||||
delay(3000);
|
||||
LEDS.addLeds<SMART_MATRIX>(leds,NUM_LEDS);
|
||||
LEDS.setBrightness(96);
|
||||
|
||||
// Initialize our coordinates to some random values
|
||||
x = random16();
|
||||
y = random16();
|
||||
z = random16();
|
||||
|
||||
// Show off smart matrix scrolling text
|
||||
pSmartMatrix->setScrollMode(wrapForward);
|
||||
pSmartMatrix->setScrollColor({0xff, 0xff, 0xff});
|
||||
pSmartMatrix->setScrollSpeed(15);
|
||||
pSmartMatrix->setScrollFont(font6x10);
|
||||
pSmartMatrix->scrollText("Smart Matrix & FastLED", -1);
|
||||
pSmartMatrix->setScrollOffsetFromEdge(10);
|
||||
}
|
||||
|
||||
// Fill the x/y array of 8-bit noise values using the inoise8 function.
|
||||
void fillnoise8() {
|
||||
for(int i = 0; i < kMatrixWidth; i++) {
|
||||
int ioffset = scale * i;
|
||||
for(int j = 0; j < kMatrixHeight; j++) {
|
||||
int joffset = scale * j;
|
||||
noise[i][j] = inoise8(x + ioffset,y + joffset,z);
|
||||
}
|
||||
}
|
||||
z += speed;
|
||||
}
|
||||
|
||||
|
||||
void loop() {
|
||||
static uint8_t circlex = 0;
|
||||
static uint8_t circley = 0;
|
||||
|
||||
static uint8_t ihue=0;
|
||||
fillnoise8();
|
||||
for(int i = 0; i < kMatrixWidth; i++) {
|
||||
for(int j = 0; j < kMatrixHeight; j++) {
|
||||
// We use the value at the (i,j) coordinate in the noise
|
||||
// array for our brightness, and the flipped value from (j,i)
|
||||
// for our pixel's hue.
|
||||
leds[XY(i,j)] = CHSV(noise[j][i],255,noise[i][j]);
|
||||
|
||||
// You can also explore other ways to constrain the hue used, like below
|
||||
// leds[XY(i,j)] = CHSV(ihue + (noise[j][i]>>2),255,noise[i][j]);
|
||||
}
|
||||
}
|
||||
ihue+=1;
|
||||
|
||||
// N.B. this requires SmartMatrix modified w/triple buffering support
|
||||
pSmartMatrix->fillCircle(circlex % 32,circley % 32,6,CRGB(CHSV(ihue+128,255,255)));
|
||||
circlex += random16(2);
|
||||
circley += random16(2);
|
||||
LEDS.show();
|
||||
// delay(10);
|
||||
}
|
383
libraries/FastLED-3.4.0/examples/TwinkleFox/TwinkleFox.ino
Normal file
383
libraries/FastLED-3.4.0/examples/TwinkleFox/TwinkleFox.ino
Normal file
@@ -0,0 +1,383 @@
|
||||
#include "FastLED.h"
|
||||
|
||||
#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
|
||||
#warning "Requires FastLED 3.1 or later; check github for latest code."
|
||||
#endif
|
||||
|
||||
|
||||
#define NUM_LEDS 100
|
||||
#define LED_TYPE WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
#define DATA_PIN 3
|
||||
//#define CLK_PIN 4
|
||||
#define VOLTS 12
|
||||
#define MAX_MA 4000
|
||||
|
||||
// TwinkleFOX: Twinkling 'holiday' lights that fade in and out.
|
||||
// Colors are chosen from a palette; a few palettes are provided.
|
||||
//
|
||||
// This December 2015 implementation improves on the December 2014 version
|
||||
// in several ways:
|
||||
// - smoother fading, compatible with any colors and any palettes
|
||||
// - easier control of twinkle speed and twinkle density
|
||||
// - supports an optional 'background color'
|
||||
// - takes even less RAM: zero RAM overhead per pixel
|
||||
// - illustrates a couple of interesting techniques (uh oh...)
|
||||
//
|
||||
// The idea behind this (new) implementation is that there's one
|
||||
// basic, repeating pattern that each pixel follows like a waveform:
|
||||
// The brightness rises from 0..255 and then falls back down to 0.
|
||||
// The brightness at any given point in time can be determined as
|
||||
// as a function of time, for example:
|
||||
// brightness = sine( time ); // a sine wave of brightness over time
|
||||
//
|
||||
// So the way this implementation works is that every pixel follows
|
||||
// the exact same wave function over time. In this particular case,
|
||||
// I chose a sawtooth triangle wave (triwave8) rather than a sine wave,
|
||||
// but the idea is the same: brightness = triwave8( time ).
|
||||
//
|
||||
// Of course, if all the pixels used the exact same wave form, and
|
||||
// if they all used the exact same 'clock' for their 'time base', all
|
||||
// the pixels would brighten and dim at once -- which does not look
|
||||
// like twinkling at all.
|
||||
//
|
||||
// So to achieve random-looking twinkling, each pixel is given a
|
||||
// slightly different 'clock' signal. Some of the clocks run faster,
|
||||
// some run slower, and each 'clock' also has a random offset from zero.
|
||||
// The net result is that the 'clocks' for all the pixels are always out
|
||||
// of sync from each other, producing a nice random distribution
|
||||
// of twinkles.
|
||||
//
|
||||
// The 'clock speed adjustment' and 'time offset' for each pixel
|
||||
// are generated randomly. One (normal) approach to implementing that
|
||||
// would be to randomly generate the clock parameters for each pixel
|
||||
// at startup, and store them in some arrays. However, that consumes
|
||||
// a great deal of precious RAM, and it turns out to be totally
|
||||
// unnessary! If the random number generate is 'seeded' with the
|
||||
// same starting value every time, it will generate the same sequence
|
||||
// of values every time. So the clock adjustment parameters for each
|
||||
// pixel are 'stored' in a pseudo-random number generator! The PRNG
|
||||
// is reset, and then the first numbers out of it are the clock
|
||||
// adjustment parameters for the first pixel, the second numbers out
|
||||
// of it are the parameters for the second pixel, and so on.
|
||||
// In this way, we can 'store' a stable sequence of thousands of
|
||||
// random clock adjustment parameters in literally two bytes of RAM.
|
||||
//
|
||||
// There's a little bit of fixed-point math involved in applying the
|
||||
// clock speed adjustments, which are expressed in eighths. Each pixel's
|
||||
// clock speed ranges from 8/8ths of the system clock (i.e. 1x) to
|
||||
// 23/8ths of the system clock (i.e. nearly 3x).
|
||||
//
|
||||
// On a basic Arduino Uno or Leonardo, this code can twinkle 300+ pixels
|
||||
// smoothly at over 50 updates per seond.
|
||||
//
|
||||
// -Mark Kriegsman, December 2015
|
||||
|
||||
CRGBArray<NUM_LEDS> leds;
|
||||
|
||||
// Overall twinkle speed.
|
||||
// 0 (VERY slow) to 8 (VERY fast).
|
||||
// 4, 5, and 6 are recommended, default is 4.
|
||||
#define TWINKLE_SPEED 4
|
||||
|
||||
// Overall twinkle density.
|
||||
// 0 (NONE lit) to 8 (ALL lit at once).
|
||||
// Default is 5.
|
||||
#define TWINKLE_DENSITY 5
|
||||
|
||||
// How often to change color palettes.
|
||||
#define SECONDS_PER_PALETTE 30
|
||||
// Also: toward the bottom of the file is an array
|
||||
// called "ActivePaletteList" which controls which color
|
||||
// palettes are used; you can add or remove color palettes
|
||||
// from there freely.
|
||||
|
||||
// Background color for 'unlit' pixels
|
||||
// Can be set to CRGB::Black if desired.
|
||||
CRGB gBackgroundColor = CRGB::Black;
|
||||
// Example of dim incandescent fairy light background color
|
||||
// CRGB gBackgroundColor = CRGB(CRGB::FairyLight).nscale8_video(16);
|
||||
|
||||
// If AUTO_SELECT_BACKGROUND_COLOR is set to 1,
|
||||
// then for any palette where the first two entries
|
||||
// are the same, a dimmed version of that color will
|
||||
// automatically be used as the background color.
|
||||
#define AUTO_SELECT_BACKGROUND_COLOR 0
|
||||
|
||||
// If COOL_LIKE_INCANDESCENT is set to 1, colors will
|
||||
// fade out slighted 'reddened', similar to how
|
||||
// incandescent bulbs change color as they get dim down.
|
||||
#define COOL_LIKE_INCANDESCENT 1
|
||||
|
||||
|
||||
CRGBPalette16 gCurrentPalette;
|
||||
CRGBPalette16 gTargetPalette;
|
||||
|
||||
void setup() {
|
||||
delay( 3000 ); //safety startup delay
|
||||
FastLED.setMaxPowerInVoltsAndMilliamps( VOLTS, MAX_MA);
|
||||
FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS)
|
||||
.setCorrection(TypicalLEDStrip);
|
||||
|
||||
chooseNextColorPalette(gTargetPalette);
|
||||
}
|
||||
|
||||
|
||||
void loop()
|
||||
{
|
||||
EVERY_N_SECONDS( SECONDS_PER_PALETTE ) {
|
||||
chooseNextColorPalette( gTargetPalette );
|
||||
}
|
||||
|
||||
EVERY_N_MILLISECONDS( 10 ) {
|
||||
nblendPaletteTowardPalette( gCurrentPalette, gTargetPalette, 12);
|
||||
}
|
||||
|
||||
drawTwinkles( leds);
|
||||
|
||||
FastLED.show();
|
||||
}
|
||||
|
||||
|
||||
// This function loops over each pixel, calculates the
|
||||
// adjusted 'clock' that this pixel should use, and calls
|
||||
// "CalculateOneTwinkle" on each pixel. It then displays
|
||||
// either the twinkle color of the background color,
|
||||
// whichever is brighter.
|
||||
void drawTwinkles( CRGBSet& L)
|
||||
{
|
||||
// "PRNG16" is the pseudorandom number generator
|
||||
// It MUST be reset to the same starting value each time
|
||||
// this function is called, so that the sequence of 'random'
|
||||
// numbers that it generates is (paradoxically) stable.
|
||||
uint16_t PRNG16 = 11337;
|
||||
|
||||
uint32_t clock32 = millis();
|
||||
|
||||
// Set up the background color, "bg".
|
||||
// if AUTO_SELECT_BACKGROUND_COLOR == 1, and the first two colors of
|
||||
// the current palette are identical, then a deeply faded version of
|
||||
// that color is used for the background color
|
||||
CRGB bg;
|
||||
if( (AUTO_SELECT_BACKGROUND_COLOR == 1) &&
|
||||
(gCurrentPalette[0] == gCurrentPalette[1] )) {
|
||||
bg = gCurrentPalette[0];
|
||||
uint8_t bglight = bg.getAverageLight();
|
||||
if( bglight > 64) {
|
||||
bg.nscale8_video( 16); // very bright, so scale to 1/16th
|
||||
} else if( bglight > 16) {
|
||||
bg.nscale8_video( 64); // not that bright, so scale to 1/4th
|
||||
} else {
|
||||
bg.nscale8_video( 86); // dim, scale to 1/3rd.
|
||||
}
|
||||
} else {
|
||||
bg = gBackgroundColor; // just use the explicitly defined background color
|
||||
}
|
||||
|
||||
uint8_t backgroundBrightness = bg.getAverageLight();
|
||||
|
||||
for( CRGB& pixel: L) {
|
||||
PRNG16 = (uint16_t)(PRNG16 * 2053) + 1384; // next 'random' number
|
||||
uint16_t myclockoffset16= PRNG16; // use that number as clock offset
|
||||
PRNG16 = (uint16_t)(PRNG16 * 2053) + 1384; // next 'random' number
|
||||
// use that number as clock speed adjustment factor (in 8ths, from 8/8ths to 23/8ths)
|
||||
uint8_t myspeedmultiplierQ5_3 = ((((PRNG16 & 0xFF)>>4) + (PRNG16 & 0x0F)) & 0x0F) + 0x08;
|
||||
uint32_t myclock30 = (uint32_t)((clock32 * myspeedmultiplierQ5_3) >> 3) + myclockoffset16;
|
||||
uint8_t myunique8 = PRNG16 >> 8; // get 'salt' value for this pixel
|
||||
|
||||
// We now have the adjusted 'clock' for this pixel, now we call
|
||||
// the function that computes what color the pixel should be based
|
||||
// on the "brightness = f( time )" idea.
|
||||
CRGB c = computeOneTwinkle( myclock30, myunique8);
|
||||
|
||||
uint8_t cbright = c.getAverageLight();
|
||||
int16_t deltabright = cbright - backgroundBrightness;
|
||||
if( deltabright >= 32 || (!bg)) {
|
||||
// If the new pixel is significantly brighter than the background color,
|
||||
// use the new color.
|
||||
pixel = c;
|
||||
} else if( deltabright > 0 ) {
|
||||
// If the new pixel is just slightly brighter than the background color,
|
||||
// mix a blend of the new color and the background color
|
||||
pixel = blend( bg, c, deltabright * 8);
|
||||
} else {
|
||||
// if the new pixel is not at all brighter than the background color,
|
||||
// just use the background color.
|
||||
pixel = bg;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// This function takes a time in pseudo-milliseconds,
|
||||
// figures out brightness = f( time ), and also hue = f( time )
|
||||
// The 'low digits' of the millisecond time are used as
|
||||
// input to the brightness wave function.
|
||||
// The 'high digits' are used to select a color, so that the color
|
||||
// does not change over the course of the fade-in, fade-out
|
||||
// of one cycle of the brightness wave function.
|
||||
// The 'high digits' are also used to determine whether this pixel
|
||||
// should light at all during this cycle, based on the TWINKLE_DENSITY.
|
||||
CRGB computeOneTwinkle( uint32_t ms, uint8_t salt)
|
||||
{
|
||||
uint16_t ticks = ms >> (8-TWINKLE_SPEED);
|
||||
uint8_t fastcycle8 = ticks;
|
||||
uint16_t slowcycle16 = (ticks >> 8) + salt;
|
||||
slowcycle16 += sin8( slowcycle16);
|
||||
slowcycle16 = (slowcycle16 * 2053) + 1384;
|
||||
uint8_t slowcycle8 = (slowcycle16 & 0xFF) + (slowcycle16 >> 8);
|
||||
|
||||
uint8_t bright = 0;
|
||||
if( ((slowcycle8 & 0x0E)/2) < TWINKLE_DENSITY) {
|
||||
bright = attackDecayWave8( fastcycle8);
|
||||
}
|
||||
|
||||
uint8_t hue = slowcycle8 - salt;
|
||||
CRGB c;
|
||||
if( bright > 0) {
|
||||
c = ColorFromPalette( gCurrentPalette, hue, bright, NOBLEND);
|
||||
if( COOL_LIKE_INCANDESCENT == 1 ) {
|
||||
coolLikeIncandescent( c, fastcycle8);
|
||||
}
|
||||
} else {
|
||||
c = CRGB::Black;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
// This function is like 'triwave8', which produces a
|
||||
// symmetrical up-and-down triangle sawtooth waveform, except that this
|
||||
// function produces a triangle wave with a faster attack and a slower decay:
|
||||
//
|
||||
// / \
|
||||
// / \
|
||||
// / \
|
||||
// / \
|
||||
//
|
||||
|
||||
uint8_t attackDecayWave8( uint8_t i)
|
||||
{
|
||||
if( i < 86) {
|
||||
return i * 3;
|
||||
} else {
|
||||
i -= 86;
|
||||
return 255 - (i + (i/2));
|
||||
}
|
||||
}
|
||||
|
||||
// This function takes a pixel, and if its in the 'fading down'
|
||||
// part of the cycle, it adjusts the color a little bit like the
|
||||
// way that incandescent bulbs fade toward 'red' as they dim.
|
||||
void coolLikeIncandescent( CRGB& c, uint8_t phase)
|
||||
{
|
||||
if( phase < 128) return;
|
||||
|
||||
uint8_t cooling = (phase - 128) >> 4;
|
||||
c.g = qsub8( c.g, cooling);
|
||||
c.b = qsub8( c.b, cooling * 2);
|
||||
}
|
||||
|
||||
// A mostly red palette with green accents and white trim.
|
||||
// "CRGB::Gray" is used as white to keep the brightness more uniform.
|
||||
const TProgmemRGBPalette16 RedGreenWhite_p FL_PROGMEM =
|
||||
{ CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Red,
|
||||
CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Red,
|
||||
CRGB::Red, CRGB::Red, CRGB::Gray, CRGB::Gray,
|
||||
CRGB::Green, CRGB::Green, CRGB::Green, CRGB::Green };
|
||||
|
||||
// A mostly (dark) green palette with red berries.
|
||||
#define Holly_Green 0x00580c
|
||||
#define Holly_Red 0xB00402
|
||||
const TProgmemRGBPalette16 Holly_p FL_PROGMEM =
|
||||
{ Holly_Green, Holly_Green, Holly_Green, Holly_Green,
|
||||
Holly_Green, Holly_Green, Holly_Green, Holly_Green,
|
||||
Holly_Green, Holly_Green, Holly_Green, Holly_Green,
|
||||
Holly_Green, Holly_Green, Holly_Green, Holly_Red
|
||||
};
|
||||
|
||||
// A red and white striped palette
|
||||
// "CRGB::Gray" is used as white to keep the brightness more uniform.
|
||||
const TProgmemRGBPalette16 RedWhite_p FL_PROGMEM =
|
||||
{ CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Red,
|
||||
CRGB::Gray, CRGB::Gray, CRGB::Gray, CRGB::Gray,
|
||||
CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Red,
|
||||
CRGB::Gray, CRGB::Gray, CRGB::Gray, CRGB::Gray };
|
||||
|
||||
// A mostly blue palette with white accents.
|
||||
// "CRGB::Gray" is used as white to keep the brightness more uniform.
|
||||
const TProgmemRGBPalette16 BlueWhite_p FL_PROGMEM =
|
||||
{ CRGB::Blue, CRGB::Blue, CRGB::Blue, CRGB::Blue,
|
||||
CRGB::Blue, CRGB::Blue, CRGB::Blue, CRGB::Blue,
|
||||
CRGB::Blue, CRGB::Blue, CRGB::Blue, CRGB::Blue,
|
||||
CRGB::Blue, CRGB::Gray, CRGB::Gray, CRGB::Gray };
|
||||
|
||||
// A pure "fairy light" palette with some brightness variations
|
||||
#define HALFFAIRY ((CRGB::FairyLight & 0xFEFEFE) / 2)
|
||||
#define QUARTERFAIRY ((CRGB::FairyLight & 0xFCFCFC) / 4)
|
||||
const TProgmemRGBPalette16 FairyLight_p FL_PROGMEM =
|
||||
{ CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight,
|
||||
HALFFAIRY, HALFFAIRY, CRGB::FairyLight, CRGB::FairyLight,
|
||||
QUARTERFAIRY, QUARTERFAIRY, CRGB::FairyLight, CRGB::FairyLight,
|
||||
CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight, CRGB::FairyLight };
|
||||
|
||||
// A palette of soft snowflakes with the occasional bright one
|
||||
const TProgmemRGBPalette16 Snow_p FL_PROGMEM =
|
||||
{ 0x304048, 0x304048, 0x304048, 0x304048,
|
||||
0x304048, 0x304048, 0x304048, 0x304048,
|
||||
0x304048, 0x304048, 0x304048, 0x304048,
|
||||
0x304048, 0x304048, 0x304048, 0xE0F0FF };
|
||||
|
||||
// A palette reminiscent of large 'old-school' C9-size tree lights
|
||||
// in the five classic colors: red, orange, green, blue, and white.
|
||||
#define C9_Red 0xB80400
|
||||
#define C9_Orange 0x902C02
|
||||
#define C9_Green 0x046002
|
||||
#define C9_Blue 0x070758
|
||||
#define C9_White 0x606820
|
||||
const TProgmemRGBPalette16 RetroC9_p FL_PROGMEM =
|
||||
{ C9_Red, C9_Orange, C9_Red, C9_Orange,
|
||||
C9_Orange, C9_Red, C9_Orange, C9_Red,
|
||||
C9_Green, C9_Green, C9_Green, C9_Green,
|
||||
C9_Blue, C9_Blue, C9_Blue,
|
||||
C9_White
|
||||
};
|
||||
|
||||
// A cold, icy pale blue palette
|
||||
#define Ice_Blue1 0x0C1040
|
||||
#define Ice_Blue2 0x182080
|
||||
#define Ice_Blue3 0x5080C0
|
||||
const TProgmemRGBPalette16 Ice_p FL_PROGMEM =
|
||||
{
|
||||
Ice_Blue1, Ice_Blue1, Ice_Blue1, Ice_Blue1,
|
||||
Ice_Blue1, Ice_Blue1, Ice_Blue1, Ice_Blue1,
|
||||
Ice_Blue1, Ice_Blue1, Ice_Blue1, Ice_Blue1,
|
||||
Ice_Blue2, Ice_Blue2, Ice_Blue2, Ice_Blue3
|
||||
};
|
||||
|
||||
|
||||
// Add or remove palette names from this list to control which color
|
||||
// palettes are used, and in what order.
|
||||
const TProgmemRGBPalette16* ActivePaletteList[] = {
|
||||
&RetroC9_p,
|
||||
&BlueWhite_p,
|
||||
&RainbowColors_p,
|
||||
&FairyLight_p,
|
||||
&RedGreenWhite_p,
|
||||
&PartyColors_p,
|
||||
&RedWhite_p,
|
||||
&Snow_p,
|
||||
&Holly_p,
|
||||
&Ice_p
|
||||
};
|
||||
|
||||
|
||||
// Advance to the next color palette in the list (above).
|
||||
void chooseNextColorPalette( CRGBPalette16& pal)
|
||||
{
|
||||
const uint8_t numberOfPalettes = sizeof(ActivePaletteList) / sizeof(ActivePaletteList[0]);
|
||||
static uint8_t whichPalette = -1;
|
||||
whichPalette = addmod8( whichPalette, 1, numberOfPalettes);
|
||||
|
||||
pal = *(ActivePaletteList[whichPalette]);
|
||||
}
|
209
libraries/FastLED-3.4.0/examples/XYMatrix/XYMatrix.ino
Normal file
209
libraries/FastLED-3.4.0/examples/XYMatrix/XYMatrix.ino
Normal file
@@ -0,0 +1,209 @@
|
||||
#include <FastLED.h>
|
||||
|
||||
#define LED_PIN 3
|
||||
|
||||
#define COLOR_ORDER GRB
|
||||
#define CHIPSET WS2811
|
||||
|
||||
#define BRIGHTNESS 64
|
||||
|
||||
// Helper functions for an two-dimensional XY matrix of pixels.
|
||||
// Simple 2-D demo code is included as well.
|
||||
//
|
||||
// XY(x,y) takes x and y coordinates and returns an LED index number,
|
||||
// for use like this: leds[ XY(x,y) ] == CRGB::Red;
|
||||
// No error checking is performed on the ranges of x and y.
|
||||
//
|
||||
// XYsafe(x,y) takes x and y coordinates and returns an LED index number,
|
||||
// for use like this: leds[ XY(x,y) ] == CRGB::Red;
|
||||
// Error checking IS performed on the ranges of x and y, and an
|
||||
// index of "-1" is returned. Special instructions below
|
||||
// explain how to use this without having to do your own error
|
||||
// checking every time you use this function.
|
||||
// This is a slightly more advanced technique, and
|
||||
// it REQUIRES SPECIAL ADDITIONAL setup, described below.
|
||||
|
||||
|
||||
// Params for width and height
|
||||
const uint8_t kMatrixWidth = 16;
|
||||
const uint8_t kMatrixHeight = 16;
|
||||
|
||||
// Param for different pixel layouts
|
||||
const bool kMatrixSerpentineLayout = true;
|
||||
const bool kMatrixVertical = false;
|
||||
// Set 'kMatrixSerpentineLayout' to false if your pixels are
|
||||
// laid out all running the same way, like this:
|
||||
//
|
||||
// 0 > 1 > 2 > 3 > 4
|
||||
// |
|
||||
// .----<----<----<----'
|
||||
// |
|
||||
// 5 > 6 > 7 > 8 > 9
|
||||
// |
|
||||
// .----<----<----<----'
|
||||
// |
|
||||
// 10 > 11 > 12 > 13 > 14
|
||||
// |
|
||||
// .----<----<----<----'
|
||||
// |
|
||||
// 15 > 16 > 17 > 18 > 19
|
||||
//
|
||||
// Set 'kMatrixSerpentineLayout' to true if your pixels are
|
||||
// laid out back-and-forth, like this:
|
||||
//
|
||||
// 0 > 1 > 2 > 3 > 4
|
||||
// |
|
||||
// |
|
||||
// 9 < 8 < 7 < 6 < 5
|
||||
// |
|
||||
// |
|
||||
// 10 > 11 > 12 > 13 > 14
|
||||
// |
|
||||
// |
|
||||
// 19 < 18 < 17 < 16 < 15
|
||||
//
|
||||
// Bonus vocabulary word: anything that goes one way
|
||||
// in one row, and then backwards in the next row, and so on
|
||||
// is call "boustrophedon", meaning "as the ox plows."
|
||||
|
||||
|
||||
// This function will return the right 'led index number' for
|
||||
// a given set of X and Y coordinates on your matrix.
|
||||
// IT DOES NOT CHECK THE COORDINATE BOUNDARIES.
|
||||
// That's up to you. Don't pass it bogus values.
|
||||
//
|
||||
// Use the "XY" function like this:
|
||||
//
|
||||
// for( uint8_t x = 0; x < kMatrixWidth; x++) {
|
||||
// for( uint8_t y = 0; y < kMatrixHeight; y++) {
|
||||
//
|
||||
// // Here's the x, y to 'led index' in action:
|
||||
// leds[ XY( x, y) ] = CHSV( random8(), 255, 255);
|
||||
//
|
||||
// }
|
||||
// }
|
||||
//
|
||||
//
|
||||
uint16_t XY( uint8_t x, uint8_t y)
|
||||
{
|
||||
uint16_t i;
|
||||
|
||||
if( kMatrixSerpentineLayout == false) {
|
||||
if (kMatrixVertical == false) {
|
||||
i = (y * kMatrixWidth) + x;
|
||||
} else {
|
||||
i = kMatrixHeight * (kMatrixWidth - (x+1))+y;
|
||||
}
|
||||
}
|
||||
|
||||
if( kMatrixSerpentineLayout == true) {
|
||||
if (kMatrixVertical == false) {
|
||||
if( y & 0x01) {
|
||||
// Odd rows run backwards
|
||||
uint8_t reverseX = (kMatrixWidth - 1) - x;
|
||||
i = (y * kMatrixWidth) + reverseX;
|
||||
} else {
|
||||
// Even rows run forwards
|
||||
i = (y * kMatrixWidth) + x;
|
||||
}
|
||||
} else { // vertical positioning
|
||||
if ( x & 0x01) {
|
||||
i = kMatrixHeight * (kMatrixWidth - (x+1))+y;
|
||||
} else {
|
||||
i = kMatrixHeight * (kMatrixWidth - x) - (y+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
// Once you've gotten the basics working (AND NOT UNTIL THEN!)
|
||||
// here's a helpful technique that can be tricky to set up, but
|
||||
// then helps you avoid the needs for sprinkling array-bound-checking
|
||||
// throughout your code.
|
||||
//
|
||||
// It requires a careful attention to get it set up correctly, but
|
||||
// can potentially make your code smaller and faster.
|
||||
//
|
||||
// Suppose you have an 8 x 5 matrix of 40 LEDs. Normally, you'd
|
||||
// delcare your leds array like this:
|
||||
// CRGB leds[40];
|
||||
// But instead of that, declare an LED buffer with one extra pixel in
|
||||
// it, "leds_plus_safety_pixel". Then declare "leds" as a pointer to
|
||||
// that array, but starting with the 2nd element (id=1) of that array:
|
||||
// CRGB leds_with_safety_pixel[41];
|
||||
// CRGB* const leds( leds_plus_safety_pixel + 1);
|
||||
// Then you use the "leds" array as you normally would.
|
||||
// Now "leds[0..N]" are aliases for "leds_plus_safety_pixel[1..(N+1)]",
|
||||
// AND leds[-1] is now a legitimate and safe alias for leds_plus_safety_pixel[0].
|
||||
// leds_plus_safety_pixel[0] aka leds[-1] is now your "safety pixel".
|
||||
//
|
||||
// Now instead of using the XY function above, use the one below, "XYsafe".
|
||||
//
|
||||
// If the X and Y values are 'in bounds', this function will return an index
|
||||
// into the visible led array, same as "XY" does.
|
||||
// HOWEVER -- and this is the trick -- if the X or Y values
|
||||
// are out of bounds, this function will return an index of -1.
|
||||
// And since leds[-1] is actually just an alias for leds_plus_safety_pixel[0],
|
||||
// it's a totally safe and legal place to access. And since the 'safety pixel'
|
||||
// falls 'outside' the visible part of the LED array, anything you write
|
||||
// there is hidden from view automatically.
|
||||
// Thus, this line of code is totally safe, regardless of the actual size of
|
||||
// your matrix:
|
||||
// leds[ XYsafe( random8(), random8() ) ] = CHSV( random8(), 255, 255);
|
||||
//
|
||||
// The only catch here is that while this makes it safe to read from and
|
||||
// write to 'any pixel', there's really only ONE 'safety pixel'. No matter
|
||||
// what out-of-bounds coordinates you write to, you'll really be writing to
|
||||
// that one safety pixel. And if you try to READ from the safety pixel,
|
||||
// you'll read whatever was written there last, reglardless of what coordinates
|
||||
// were supplied.
|
||||
|
||||
#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
|
||||
CRGB leds_plus_safety_pixel[ NUM_LEDS + 1];
|
||||
CRGB* const leds( leds_plus_safety_pixel + 1);
|
||||
|
||||
uint16_t XYsafe( uint8_t x, uint8_t y)
|
||||
{
|
||||
if( x >= kMatrixWidth) return -1;
|
||||
if( y >= kMatrixHeight) return -1;
|
||||
return XY(x,y);
|
||||
}
|
||||
|
||||
|
||||
// Demo that USES "XY" follows code below
|
||||
|
||||
void loop()
|
||||
{
|
||||
uint32_t ms = millis();
|
||||
int32_t yHueDelta32 = ((int32_t)cos16( ms * (27/1) ) * (350 / kMatrixWidth));
|
||||
int32_t xHueDelta32 = ((int32_t)cos16( ms * (39/1) ) * (310 / kMatrixHeight));
|
||||
DrawOneFrame( ms / 65536, yHueDelta32 / 32768, xHueDelta32 / 32768);
|
||||
if( ms < 5000 ) {
|
||||
FastLED.setBrightness( scale8( BRIGHTNESS, (ms * 256) / 5000));
|
||||
} else {
|
||||
FastLED.setBrightness(BRIGHTNESS);
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void setup() {
|
||||
FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalSMD5050);
|
||||
FastLED.setBrightness( BRIGHTNESS );
|
||||
}
|
Reference in New Issue
Block a user