First version of the Neopixel workshop code:
//Ne0n00bp1x3l l1br4ry
// Bodged together by Byron for TheEdge's Arduino 101 'neopixel' workshop
// With help from Vince
//Code from:
//Adafruit's 'strandtest' example
//https://www.tweaking4all.com/hardware/arduino/adruino-led-strip-effects/
//https://forum.arduino.cc/index.php?topic=418923.msg2886563#msg2886563
//And other places
// This line makes the AdaFruit NeoPixel library available to this sketch.
// The NeoPixel library handles the gory details of writing a high speed, finicky set of commands to the pixels.
#include <Adafruit_NeoPixel.h>
// This line makes the word "PIN_LEDS" look like the number '6' to the computer. Your strip should be attached to pin 6 on your Arduino!
// We could just use the number '6' instead, but using a named constant describes what the number is FOR, and makes your code easier to read and fix.
#define PIN_LEDS 6
// How many LEDs are in the string
// Each segment is 30 LEDs long. A meter is 60 LEDs. A full spool is 5m long, so 300 LEDs
// Don't set this any longer than your strip.
// 30 LEDs is about as much as a single normal USB2 port can power. If you want to light up longer strips, you'll need an external power supply
// (or you might blow up your USB port or computer).
#define NUM_LEDS 30
// Configure the neopixel library with the correct settings for the strips we are using
// in order: how many LEDs in the connected strip, which Arduino pin the strip is connected to, the RGB ordering our pixels use (can vary), and the speed.
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN_LEDS, NEO_GRB + NEO_KHZ800);
// The Arduino builtin function setup() runs once, when the microcontroller starts up. Put any once-off setup code in setup()
void setup() {
// Turn on strip
strip.begin();
// Writes LED values to strip, then tells strip to turn ON.
// Changes you make to the LEDs won't display until you call show() !!
strip.show();
// The overall brightness of all the LEDs can be adjusted using setBrightness().
//This takes a single argument, a number in the range 0 (off) to 255 (max brightness).
//For example, to set a strip to 1/2 brightness:
strip.setBrightness(128);
} // end setup()
// The Arduino runs the loop() function in an infinite repeat, until it is turned off. Put your program code in here
void loop() {
// setAllRGB will fill the entire strip with a single color - specified as Red, Green, Blue components
// Because of the way eyes work, a mix of different amounts of red, green and blue light can look like other colors - eg yellow
// Because of this, you'll see colors specified a lot as a red, green, blue (RGB) triplet.
// This sets all three channels to zero (off).
setAllRGB(0,0,0);
// Now, update the strip
showStrip();
/*
* Setting LED colours individually.
* setPixelRGB() changes a single pixel in the strip
* First number is the position of the pixel to set. Pixel zero is the FIRST pixel in the string, and pixel 1 is the SECOND, and so on.
* The next three parameters are the 'red', then 'green' then 'blue' values.
* Each channel can be from 0 to 255, but not greater, and not negative. Also, no fractional numbers (eg 2.5)
*/
setPixelRGB(0, 255,0,0); // Set the FIRST pixel in the string to full brightness RED
showStrip(); // Update change to the strip
// The Arduino builtin delay() function pauses program execution for the indicated number of milliseconds. There are 1000 mS in one second.
delay(200); // Wait 200mS
setPixelRGB(1,0,255,0); // Set the SECOND pixel to full brightness GREEN
showStrip(); // Update change to the strip
delay(200); // Wait 200mS
setPixelRGB(2,0,0,255); // Set the third pixel to full brightness BLUE
showStrip(); // Update change to the strip
delay(500); // Wait 500mS
setPixelRGB(0,0,0,0); // First pixel off
setPixelRGB(1,0,0,0); // Second pixel off
setPixelRGB(2,0,0,0); // Third pixel off
showStrip(); // Update change to the strip
delay(1000); // Wait 1000mS
/*
* Instead of using RGB values, you can 'pack' them into a single value (a big number) and store that number in a named container, called a VARIABLE.
* This lets you pass around just one value, instead of three.
* When you use a variable's name in your code, the Arduino retrieves the contents of that variable and uses it right there.
* This allows you to change the colour without changing your whole pattern.
* The first time you refer to a variable, the Arduino creates it. When you create a variable, you need to tell the Arduino what 'shape' it is. This is what the 'uint32_t' bit is for.
* 'uint32_t' defines the variable as 'big enough to hold an Unsigned INTeger of 32 bits length', which can hold a single whole number between 0 and 4.2 billion.
* You only need this the first time you refer to a variable.
*/
// Full RED and GREEN make YELLOW looking light
uint32_t mycolour1 = RGBtoPacked(255,255, 0);
// Full RED and BLUE make MAGENTA (reddish purple) looking light
uint32_t mycolour2 = RGBtoPacked(255, 0, 255);
// Full GREEN and BLUE make CYAN (light blue) light
uint32_t mycolour3 = RGBtoPacked(0, 255, 255);
// Setting everything to 0 turns off the pixel entirely, for 'black'
uint32_t mycolour4 = RGBtoPacked(0, 0, 0);
// Setting RED, GREEN and BLUE to equal amounts gives a WHITE appearing light
uint32_t mycolour5 = RGBtoPacked(255, 255, 255);
// You can assign variables to other variables... and using descriptive names makes your code easier to use, and fix!
uint32_t color_White = mycolour5;
// Changing mycolour5 won't change color_White. Assignment does not 'link' variables, the data is copied from the second to the first and now lives in two places.
mycolour5 = RGBtoPacked(0, 64, 0); // careful of spelling!!
// What color is in mycolour5 now?
// Lots of other colours are possible by choosing different mixes of red, green and blue!
setPixelPacked(0, mycolour1); // Set first pixel to the color stored in mycolor1
setPixelPacked(2, mycolour1); // Set third pixel to the color stored in mycolor1 also
showStrip();
delay(500);
setPixelPacked(1, mycolour2); // Second pixel
setPixelPacked(4, mycolour2); // Fifth pixel
showStrip();
delay(500);
// let's define a variable for the pixel position, too.
uint8_t pixelPosition = 3;
setPixelPacked(pixelPosition, mycolour3); // Fourth pixel
pixelPosition = 5;
setPixelPacked(pixelPosition, mycolour3); // Sixth pixel
showStrip();
delay(1000);
// And now, turn all 6 pixels off, by assigning the same color ('black') to each
setPixelPacked(0, mycolour4);
setPixelPacked(1, mycolour4);
setPixelPacked(2, mycolour4);
setPixelPacked(3, mycolour4);
setPixelPacked(4, mycolour4);
setPixelPacked(5, mycolour4);
showStrip();
delay(1000);
// You can use a code structure called a 'FOR loop' to do repetitious things. if used, this should have the same effect as the six setPixelPacked calls above:
/*
* for ( uint8_t position = 0; position < 6; ++position ) {
* setPixelPacked(position, mycolour4);
* }
* showStrip();
* delay(1000);
*/
/* Predefined pretty animation patterns, for you to play with. The code of each function is at the bottom of this file - you can change it if you like
* ... but keep a backup, in case you break it!
*
* colorWipe() is a function that will animate progressively filling the entire strip with a single color.
* You can write to only every second, third, ... pixel by changing the second parameter.
* First parameter is a color, in PackedColor format (32 bit unsigned integer).
* Second: set N, to update every Nth pixel ( 1 = all pixels 2 = every second 3 = every third, and so on)
* third: starting pixel position - skips updating all pixels before this
* fourth: delay (in mS) between each frame of the fill animation
*/
colorWipe(RGBtoPacked(255, 0, 0), 1, 0, 50); // Every Red
delay(500);
colorWipe(RGBtoPacked(0, 255, 0), 2, 0, 50); // Every second green
delay(500);
colorWipe(RGBtoPacked(0, 0, 255), 2, 1, 50); // Replace just the red with Blue
delay(500);
colorRetract(RGBtoPacked(255, 255, 0), 3, 1, 100); // Yellow backwards, every third slower
delay(500);
colorWipe(RGBtoPacked(0, 0, 0), 2, 0, 20); // Quickly half off forward
colorRetract(RGBtoPacked(0, 0, 0), 2, 0, 20); // Quickly half off backwards
delay(1000);
/*
* FadeIn() evenly brightens the entire strip from black to full intensity of the supplied colour. FadeOut() fades entire strip from full brightness to dark.
* First parameter is packed colour, second is mS per frame of animation.
*/
FadeIn(RGBtoPacked(255, 255, 255), 10); // white
FadeOut(RGBtoPacked(255, 255, 255), 0); // white
delay(1000);
/*
* Fade from one colour to another, using two sets of Red Green Blue values
* Note: This won't produse the most accurate colours, but it's simple.
*/
// RGBcrossFade(RGBtoPacked(10, 10, 255),RGBtoPacked(255, 0, 100),10);
// delay(500);
RGBcrossFade(RGBtoPacked(0, 0, 255),RGBtoPacked(255, 0, 0),10);
delay(1000);
/* You can combine the two!
* This uses colours defined eairler
*/
FadeIn(mycolour1, 10); // Fade up first colour
RGBcrossFade(mycolour1,mycolour3,10); // Go from first to second
RGBcrossFade(mycolour3,mycolour2,10); // Go from second to third
FadeOut(mycolour2, 10); // Fade down third colour
delay(1000);
/*
* Scanner style examples:
* (PackedColor, EyeSize, SpeedDelay, ReturnDelay);
*/
RightToLeft(mycolour2, 4, 10, 200);
LeftToRight(mycolour2, 4, 10, 200);
OutsideToCenter(mycolour1, 2, 10, 200);
CenterToOutside(mycolour1, 2, 10, 200);
delay(1000);
/*
* Cylon aka. Larsen scanner
* Cylon() function takes 4 parameters, where the first is your desired colour. Packed
* The 4th parameter (EyeSize) determines how many LEDs run around, or: the width of the “eye” (outer 2, faded, LEDs not counted).
* The 5th parameter (SpeedDelay) influences how fast the eye moves, higher values means slow movement.
* The last parameter (ReturnDelay) sets how much time it should wait to bounce back.
*/
// BROKEN
// CylonBounce(RGBtoPacked(255, 0, 0), 4, 10, 50);
// delay(1000);
/*
* Strobe:
* The first is PackedColour 2nd parameter (StrobeCount) indicates how many flashes you’d like to see.
* Parameters 3 (FlashDelay) delay between each individual flash.
* EPILEPTICS BEWARE!!
*/
//Strobe(mycolour1, 20, 50);
//Strobe(mycolour2, 20, 50);
//Strobe(mycolour3, 20, 50);
//Strobe(mycolour4, 20, 50);
//delay(1000);
/*
* Twinkle
* first is Packed Colour
* The 2th parameter (Count) determines how many pixels will be done in one run,
* 3rd 5th parameter determines how much time will be paused between individual pixels (speed).
* The 4th parameter (OnlyOne) should be true if you want to see only one LED at a time. If it’s set to false then all “Count” number of LEDs will be visible (added one at a time).
*/
Twinkle(RGBtoPacked(10, 10, 255), 10, 100, false);
delay(1000);
/*
* This is a variation on the Twinkle() effect.
* Difference is that the colors are now randomly generated, and therefor color parameter is no longer needed.
* The first parameter (Count) determines how many pixels will be done in one run
* The second parameter determines how much time will be paused between individual pixels (speed).
* The last parameter (OnlyOne) should be true if you want to see only one LED at a time.
* If it’s set to false then all “Count” number of LEDs will be visible (added one at a time).
*/
TwinkleRandom(20, 100, true);
delay(1000);
/*
* Randomly blink LEDs
* Takes PackedColour as first parameter, delay between pixels as second
*/
Sparkle(RGBtoPacked(255,255,255), 300);
/* An alternative to specifying numbers by R,G,B is to specify them by Hue (color), Saturation (hcolor intensity. 0 = grayscale 255 = rainbow) and Value (how bright)
* This is referred to as HSV (sometimes HSL where L = Luminance). Using this representation, you can independently control the color, saturation and brightness of your colours easily.
* The Neopixel library does not understand HSV colors, so they still need to be converted to RGB for the strip pixels to use, but we have a function for that!
* The h12sv2rgb() function converts a Hue, Saturation, Value color into a packed RGB one that you can set pixels to.
*/
// write a rainbow to the strip
uint32_t aHue;
for ( pixelPosition = 0; pixelPosition < NUM_LEDS; ++pixelPosition) {
aHue = (1536 * pixelPosition) / NUM_LEDS;
setPixelPacked(pixelPosition, hsvToPacked(aHue, 255, 255));
}
showStrip();
delay(5000);
// this function writes all 1536 hues to the strip
for( uint16_t hue = 0; hue < 1536; ) {
for ( uint8_t pixelPosition = 0; pixelPosition < NUM_LEDS; ++pixelPosition) {
setPixelPacked(pixelPosition, hsvToPacked(hue, 255, 255));
hue = hue + 1;
}
showStrip();
delay(100);
}
delay(250);
setAllRGB(0,0,0);
/*
* More complicated and thus less generel effect
* Some of these take a long time to run or have other problems
* One or two might not be able to be combined with other effects
*/
/*
* Rainbow Cycle
* cycles rainbow colors, where the only parameter is the speed delay.
* Completes after it goes through all colours
*/
//rainbowCycle(20);
/*
* This effect looks best when hanging your LED strip vertical and it simulates a one LED wide “fire”,
* and is adapted from an example in FastLED, which is adapted from work done by Mark Kriegsman (called “Fire2012”).
* This function takes 3 parameters.
* The first one (Cooling) indicates how fast a flame cools down. More cooling means shorter flames, and the recommended values are between 20 and 100. 50 seems the nicest.
* The Second parameter (Sparking), indicates the chance (out of 255) that a spark will ignite. A higher value makes the fire more active. Suggested values lay between 50 and 200, with my personal preference being 120.
* The last parameter (SpeedDelay) allows you to slow down the fire activity … a higher value makes the flame appear slower.
*/
//Fire(55,120,15);
//byte colors[3][3] = { {0xff, 0,0}, {0xff, 0xff, 0xff}, {0 , 0 , 0xff} };
//BouncingColoredBalls(3, colors);
} // End loop()
// --------------------------------- Functions and other messy stuff below here! ------------------------
// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t every, uint8_t offset, int wait) {
if(every<1){every=1;}
for(uint16_t i=offset; i<NUM_LEDS; i=i+every) {
setPixelPacked(i, c);
showStrip();
delay(wait);
}
}
// Same as colorWipe but backwards
void colorRetract(uint32_t c, uint8_t every, uint8_t offset, uint8_t wait) {
if(every<1){every=1;}
for(int i=NUM_LEDS+1-offset; i>-1; i=i-every) {
setPixelPacked(i, c);
showStrip();
delay(wait);
}
}
//https://forum.arduino.cc/index.php?topic=418923.msg2886563#msg2886563
void RGBcrossFade(const uint32_t startColor, const uint32_t endColor, int speed) {
byte startRed = (startColor >> 16) & 0xff;
byte startGreen = (startColor >> 8) & 0xff;
byte startBlue = startColor & 0xff;
byte endRed = (endColor >> 16) & 0xff;
byte endGreen = (endColor >> 8) & 0xff;
byte endBlue = endColor & 0xff;
// for each step in the cross-fade
for (int step = 0; step < 256; step++) {
byte red = map(step, 0, 255, startRed, endRed);
byte green = map(step, 0, 255, startGreen, endGreen);
byte blue = map(step, 0, 255, startBlue, endBlue);
setAllRGB(red,green,blue);
delay(speed);
}
}
void rainbowCycle(int SpeedDelay) {
uint16_t i, j;
for(j=0; j<256; j++) { // cycle all colors on wheel
for(i=0; i< NUM_LEDS; i++) {
setPixelPacked(i, Wheel(((i * 256 / NUM_LEDS) + j) & 255));
}
showStrip();
delay(SpeedDelay);
}
}
void Strobe(const uint32_t c, int StrobeCount, int FlashDelay){
for(int j = 0; j < StrobeCount; j++) {
setAllPacked(c);
showStrip();
delay(FlashDelay);
setAllRGB(0,0,0);
showStrip();
delay(FlashDelay);
}
}
void CenterToOutside(const uint32_t c, int EyeSize, int SpeedDelay, int ReturnDelay) {
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
for(int i =((NUM_LEDS-EyeSize)/2); i>=0; i--) {
setAllRGB(0,0,0);
setPixelRGB(i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(i+j, red, green, blue);
}
setPixelRGB(i+EyeSize+1, red/10, green/10, blue/10);
setPixelRGB(NUM_LEDS-i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(NUM_LEDS-i-j, red, green, blue);
}
setPixelRGB(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
showStrip();
delay(SpeedDelay);
}
delay(ReturnDelay);
}
void OutsideToCenter(const uint32_t c, int EyeSize, int SpeedDelay, int ReturnDelay) {
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
for(int i = 0; i<=((NUM_LEDS-EyeSize)/2); i++) {
setAllRGB(0,0,0);
setPixelRGB(i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(i+j, red, green, blue);
}
setPixelRGB(i+EyeSize+1, red/10, green/10, blue/10);
setPixelRGB(NUM_LEDS-i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(NUM_LEDS-i-j, red, green, blue);
}
setPixelRGB(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
showStrip();
delay(SpeedDelay);
}
delay(ReturnDelay);
}
void LeftToRight(const uint32_t c, int EyeSize, int SpeedDelay, int ReturnDelay) {
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
setAllRGB(0,0,0);
setPixelRGB(i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(i+j, red, green, blue);
}
setPixelRGB(i+EyeSize+1, red/10, green/10, blue/10);
showStrip();
delay(SpeedDelay);
}
delay(ReturnDelay);
}
void RightToLeft(const uint32_t c, int EyeSize, int SpeedDelay, int ReturnDelay) {
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
setAllRGB(0,0,0);
setPixelRGB(i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(i+j, red, green, blue);
}
setPixelRGB(i+EyeSize+1, red/10, green/10, blue/10);
showStrip();
delay(SpeedDelay);
}
delay(ReturnDelay);
}
void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
setAllRGB(0,0,0);
setPixelRGB(i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(i+j, red, green, blue);
}
setPixelRGB(i+EyeSize+1, red/10, green/10, blue/10);
showStrip();
delay(SpeedDelay);
}
delay(ReturnDelay);
for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
setAllRGB(0,0,0);
setPixelRGB(i, red/10, green/10, blue/10);
for(int j = 1; j <= EyeSize; j++) {
setPixelRGB(i+j, red, green, blue);
}
setPixelRGB(i+EyeSize+1, red/10, green/10, blue/10);
showStrip();
delay(SpeedDelay);
}
delay(ReturnDelay);
}
void FadeIn(const uint32_t c, int delayval){
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
float r, g, b;
for(int k = 0; k < 256; k=k+1) {
r = (k/256.0)*red;
g = (k/256.0)*green;
b = (k/256.0)*blue;
setAllRGB(r,g,b);
showStrip();
delay(delayval);
}
}
void FadeOut(const uint32_t c, int delayval){
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
float r, g, b;
for(int k = 255; k >= 0; k=k-2) {
r = (k/256.0)*red;
g = (k/256.0)*green;
b = (k/256.0)*blue;
setAllRGB(r,g,b);
showStrip();
delay(delayval);
}
}
void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {
setAllRGB(0,0,0);
for (int i=0; i<Count; i++) {
setPixelRGB(random(NUM_LEDS),random(0,255),random(0,255),random(0,255));
showStrip();
delay(SpeedDelay);
if(OnlyOne) {
setAllRGB(0,0,0);
}
}
delay(SpeedDelay);
}
void Twinkle(const uint32_t c, int Count, int SpeedDelay, boolean OnlyOne) {
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
setAllRGB(0,0,0);
for (int i=0; i<Count; i++) {
setPixelRGB(random(NUM_LEDS),red,green,blue);
showStrip();
delay(SpeedDelay);
if(OnlyOne) {
setAllRGB(0,0,0);
}
}
delay(SpeedDelay);
}
void BouncingColoredBalls(int BallCount, byte colors[][3]) {
float Gravity = -9.81;
int StartHeight = 1;
float Height[BallCount];
float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );
float ImpactVelocity[BallCount];
float TimeSinceLastBounce[BallCount];
int Position[BallCount];
long ClockTimeSinceLastBounce[BallCount];
float Dampening[BallCount];
for (int i = 0 ; i < BallCount ; i++) {
ClockTimeSinceLastBounce[i] = millis();
Height[i] = StartHeight;
Position[i] = 0;
ImpactVelocity[i] = ImpactVelocityStart;
TimeSinceLastBounce[i] = 0;
Dampening[i] = 0.90 - float(i)/pow(BallCount,2);
}
while (true) {
for (int i = 0 ; i < BallCount ; i++) {
TimeSinceLastBounce[i] = millis() - ClockTimeSinceLastBounce[i];
Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;
if ( Height[i] < 0 ) {
Height[i] = 0;
ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
ClockTimeSinceLastBounce[i] = millis();
if ( ImpactVelocity[i] < 0.01 ) {
ImpactVelocity[i] = ImpactVelocityStart;
}
}
Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);
}
for (int i = 0 ; i < BallCount ; i++) {
setPixelRGB(Position[i],colors[i][0],colors[i][1],colors[i][2]);
}
showStrip();
setAllRGB(0,0,0);
}
}
void Fire(int Cooling, int Sparking, int SpeedDelay) {
static byte heat[NUM_LEDS];
int cooldown;
// Step 1. Cool down every cell a little
for( int i = 0; i < NUM_LEDS; i++) {
cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2);
if(cooldown>heat[i]) {
heat[i]=0;
} else {
heat[i]=heat[i]-cooldown;
}
}
// 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' near the bottom
if( random(255) < Sparking ) {
int y = random(7);
heat[y] = heat[y] + random(160,255);
//heat[y] = random(160,255);
}
// Step 4. Convert heat to LED colors
for( int j = 0; j < NUM_LEDS; j++) {
setPixelHeatColor(j, heat[j] );
}
showStrip();
delay(SpeedDelay);
}
void setPixelHeatColor (int Pixel, byte temperature) {
// Scale 'heat' down from 0-255 to 0-191
byte t192 = round((temperature/255.0)*191);
// calculate ramp up from
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // scale up to 0..252
// figure out which third of the spectrum we're in:
if( t192 > 0x80) { // hottest
setPixelRGB(Pixel, 255, 255, heatramp);
} else if( t192 > 0x40 ) { // middle
setPixelRGB(Pixel, 255, heatramp, 0);
} else { // coolest
setPixelRGB(Pixel, heatramp, 0, 0);
}
}
void Sparkle(const uint32_t c, int SpeedDelay) {
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
int Pixel = random(NUM_LEDS);
setPixelRGB(Pixel,red,green,blue);
showStrip();
delay(SpeedDelay);
setPixelRGB(Pixel,0,0,0);
}
/*
byte * Wheel(byte WheelPos) {
static byte c[3];
if(WheelPos < 85) {
c[0]=WheelPos * 3;
c[1]=255 - WheelPos * 3;
c[2]=0;
} else if(WheelPos < 170) {
WheelPos -= 85;
c[0]=255 - WheelPos * 3;
c[1]=0;
c[2]=WheelPos * 3;
} else {
WheelPos -= 170;
c[0]=0;
c[1]=WheelPos * 3;
c[2]=255 - WheelPos * 3;
}
return c;
}
*/
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if(WheelPos < 85) {
return RGBtoPacked(255 - WheelPos * 3, 0, WheelPos * 3);
}
if(WheelPos < 170) {
WheelPos -= 85;
return RGBtoPacked(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return RGBtoPacked(WheelPos * 3, 255 - WheelPos * 3, 0);
}
void showStrip() {
#ifdef ADAFRUIT_NEOPIXEL_H
// NeoPixel
strip.show();
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
// FastLED
FastLED.show();
#endif
}
// RGB sets
void setPixelRGB(int Pixel, byte red, byte green, byte blue) {
#ifdef ADAFRUIT_NEOPIXEL_H
// NeoPixel
strip.setPixelColor(Pixel, strip.Color(red, green, blue));
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
// FastLED
leds[Pixel].r = red;
leds[Pixel].g = green;
leds[Pixel].b = blue;
#endif
}
void setAllRGB(byte red, byte green, byte blue) {
for(int i = 0; i < NUM_LEDS; i++ ) {
setPixelRGB(i, red, green, blue);
}
showStrip();
}
// Packed sets. Thanks to: https://forum.arduino.cc/index.php?topic=512914.0
// Convert separate R,G,B into packed 32-bit RGB color.
// Packed format is always RGB, regardless of LED strand color order.
uint32_t RGBtoPacked(uint8_t r, uint8_t g, uint8_t b) {
return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
}
void setPixelPacked(int Pixel, uint32_t c) {
#ifdef ADAFRUIT_NEOPIXEL_H
// NeoPixel
strip.setPixelColor(Pixel, c);
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
// FastLED
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
leds[Pixel].r = red;
leds[Pixel].g = green;
leds[Pixel].b = blue;
#endif
}
void setAllPacked(uint32_t c) {
for(int i = 0; i < NUM_LEDS; i++ ) {
setPixelPacked(i, c);
}
showStrip();
}
void printColorPacked(uint32_t c){
uint8_t *p,
red = (uint8_t)(c >> 16),
green = (uint8_t)(c >> 8),
blue = (uint8_t)c;
Serial.print("C:"); Serial.print(c,HEX);
Serial.print(" R:"); Serial.print(red);
Serial.print(" G:"); Serial.print(green);
Serial.print(" B:"); Serial.println(blue);
}
/* H12SV - HSV algorithm with 12 bit Hue component (1536 possible hues)
* Created by: Vince Sutton
* Modified from 8 bit HSV -> RGB algorithms.
* Not final version, may contain bugs :) YMMV!
* Note only lowest 12 bits of hue are used (value 0 - 1535) - if you assign higher numbers, the final hue will be something strange.
*/
uint32_t hsvToPacked(uint16_t hue, uint8_t sat, uint8_t val) {
if ( sat == 0 // no chroma component, R G B even
|| val == 0) // 0% bright, return black
{
return RGBtoPacked(val, val, val);
}
uint8_t r = 0;
uint8_t g = 0;
uint8_t b = 0;
uint16_t tmp = sat * val;
uint8_t chroma = tmp / 255;
uint16_t hue2 = (hue % 1536);
uint8_t chroma2 = hue2 % 256;
if( hue2 > 1279 ) { // magenta -> red
r = chroma;
b = ((255 - chroma2) * chroma) / 255;
}
else if (hue2 > 1023 ) {
r = (chroma2 * chroma) / 255;
b = chroma;
}
else if ( hue2 > 767) {
g = ((255 - chroma2) * chroma) / 255;
b = chroma;
}
else if ( hue2 > 511) {
g = chroma;
b = (chroma2 * chroma) / 255;
}
else if ( hue2 > 255 ) {
r = ((255 - chroma2) * chroma) / 255;
g = chroma;
}
else { // hue < 255
r = chroma;
g = (chroma2 * chroma) / 255;
}
uint8_t sv = val - chroma;
return RGBtoPacked(
r + sv, g + sv, b + sv);
}