Strip hinzugefügt
This commit is contained in:
starcalc
parent
5b6443fd9c
commit
54fbb46f25
|
|
@ -0,0 +1,654 @@
|
||||||
|
#include "NeoPatterns.h"
|
||||||
|
|
||||||
|
NeoPatterns::NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type, void (*callback)()) :
|
||||||
|
Adafruit_NeoPixel(pixels, pin, type)
|
||||||
|
{
|
||||||
|
OnComplete = callback;
|
||||||
|
//Allocate a zero initialized block of memory big enough to hold "pixels" uint8_t.
|
||||||
|
pixelR = ( uint8_t* ) calloc( pixels, sizeof( uint8_t ) );
|
||||||
|
pixelG = ( uint8_t* ) calloc( pixels, sizeof( uint8_t ) );
|
||||||
|
pixelB = ( uint8_t* ) calloc( pixels, sizeof( uint8_t ) );
|
||||||
|
pixelR_buffer = ( uint8_t* ) calloc( pixels, sizeof( uint8_t ) );
|
||||||
|
pixelG_buffer = ( uint8_t* ) calloc( pixels, sizeof( uint8_t ) );
|
||||||
|
pixelB_buffer = ( uint8_t* ) calloc( pixels, sizeof( uint8_t ) );
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Update() {
|
||||||
|
if ((millis() - lastUpdate) > Interval) // time to update
|
||||||
|
{
|
||||||
|
lastUpdate = millis();
|
||||||
|
switch (ActivePattern)
|
||||||
|
{
|
||||||
|
case RAINBOW_CYCLE:
|
||||||
|
RainbowCycleUpdate();
|
||||||
|
break;
|
||||||
|
case THEATER_CHASE:
|
||||||
|
TheaterChaseUpdate();
|
||||||
|
break;
|
||||||
|
case COLOR_WIPE:
|
||||||
|
ColorWipeUpdate();
|
||||||
|
break;
|
||||||
|
case SCANNER:
|
||||||
|
ScannerUpdate();
|
||||||
|
break;
|
||||||
|
case FADE:
|
||||||
|
FadeUpdate();
|
||||||
|
break;
|
||||||
|
case RANDOM_FADE:
|
||||||
|
RandomFadeUpdate();
|
||||||
|
break;
|
||||||
|
case RANDOM_FADE_SINGLE:
|
||||||
|
RandomFadeSingleUpdate();
|
||||||
|
break;
|
||||||
|
case SMOOTH:
|
||||||
|
SmoothUpdate();
|
||||||
|
break;
|
||||||
|
case PLASMA:
|
||||||
|
PlasmaUpdate();
|
||||||
|
break;
|
||||||
|
case FILL:
|
||||||
|
break;
|
||||||
|
case RANDOM:
|
||||||
|
break;
|
||||||
|
case NONE:
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
delay(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Increment()
|
||||||
|
{
|
||||||
|
if (Direction == FORWARD)
|
||||||
|
{
|
||||||
|
Index++;
|
||||||
|
if (Index >= TotalSteps)
|
||||||
|
{
|
||||||
|
Index = 0;
|
||||||
|
if (OnComplete != NULL)
|
||||||
|
{
|
||||||
|
OnComplete(); // call the completion callback
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else // Direction == REVERSE
|
||||||
|
{
|
||||||
|
--Index;
|
||||||
|
if (Index <= 0)
|
||||||
|
{
|
||||||
|
Index = TotalSteps - 1;
|
||||||
|
if (OnComplete != NULL)
|
||||||
|
{
|
||||||
|
OnComplete(); // call the completion callback
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Reverse() {
|
||||||
|
if (Direction == FORWARD)
|
||||||
|
{
|
||||||
|
Direction = REVERSE;
|
||||||
|
Index = TotalSteps - 1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Direction = FORWARD;
|
||||||
|
Index = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Stop(uint8_t interval) {
|
||||||
|
Interval = interval;
|
||||||
|
ActivePattern = NONE;
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::None(uint8_t interval) {
|
||||||
|
Interval = interval;
|
||||||
|
if (ActivePattern != NONE) {
|
||||||
|
clear();
|
||||||
|
show();
|
||||||
|
}
|
||||||
|
ActivePattern = NONE;
|
||||||
|
}
|
||||||
|
|
||||||
|
/****************** Effects ******************/
|
||||||
|
|
||||||
|
void NeoPatterns::RainbowCycle(uint8_t interval, direction dir) {
|
||||||
|
ActivePattern = RAINBOW_CYCLE;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = 255;
|
||||||
|
Index = 0;
|
||||||
|
Direction = dir;
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::RainbowCycleUpdate()
|
||||||
|
{
|
||||||
|
for (int i = 0; i < numPixels(); i++)
|
||||||
|
{
|
||||||
|
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
Increment();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::TheaterChase(uint32_t color1, uint32_t color2, uint8_t interval, direction dir) {
|
||||||
|
ActivePattern = THEATER_CHASE;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = numPixels();
|
||||||
|
Color1 = color1;
|
||||||
|
Color2 = color2;
|
||||||
|
Index = 0;
|
||||||
|
Direction = dir;
|
||||||
|
}
|
||||||
|
void NeoPatterns::TheaterChaseUpdate() {
|
||||||
|
for (int i = 0; i < numPixels(); i++)
|
||||||
|
{
|
||||||
|
if ((i + Index) % 3 == 0)
|
||||||
|
{
|
||||||
|
setPixelColor(i, Color1);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
setPixelColor(i, Color2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
Increment();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::ColorWipe(uint32_t color, uint8_t interval, direction dir)
|
||||||
|
{
|
||||||
|
ActivePattern = COLOR_WIPE;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = numPixels();
|
||||||
|
Color1 = color;
|
||||||
|
Index = 0;
|
||||||
|
Direction = dir;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update the Color Wipe Pattern
|
||||||
|
void NeoPatterns::ColorWipeUpdate()
|
||||||
|
{
|
||||||
|
setPixelColor(Index, Color1);
|
||||||
|
show();
|
||||||
|
Increment();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initialize for a SCANNNER
|
||||||
|
void NeoPatterns::Scanner(uint32_t color1, uint8_t interval, bool colorful, bool spiral)
|
||||||
|
{
|
||||||
|
ActivePattern = SCANNER;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = (numPixels() - 1) * 2;
|
||||||
|
Color1 = color1;
|
||||||
|
Index = 0;
|
||||||
|
wPos = 0;
|
||||||
|
this->colorful = colorful;
|
||||||
|
this->spiral = spiral;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update the Scanner Pattern
|
||||||
|
void NeoPatterns::ScannerUpdate()
|
||||||
|
{
|
||||||
|
if (colorful) {
|
||||||
|
Color1 = Wheel(wPos);
|
||||||
|
if (wPos >= 255) {
|
||||||
|
wPos = 0;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
wPos++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (int i = 0; i < numPixels(); i++)
|
||||||
|
{
|
||||||
|
int finalpos;
|
||||||
|
if (spiral) {
|
||||||
|
finalpos = numToSpiralPos(i);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
finalpos = i;
|
||||||
|
}
|
||||||
|
if (i == Index) // Scan Pixel to the right
|
||||||
|
{
|
||||||
|
setPixelColor(finalpos, Color1);
|
||||||
|
}
|
||||||
|
else if (i == TotalSteps - Index) // Scan Pixel to the left
|
||||||
|
{
|
||||||
|
setPixelColor(finalpos, Color1);
|
||||||
|
}
|
||||||
|
else // Fading tail
|
||||||
|
{
|
||||||
|
setPixelColor(finalpos, DimColor(getPixelColor(finalpos)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
Increment();
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir)
|
||||||
|
{
|
||||||
|
ActivePattern = FADE;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = steps;
|
||||||
|
Color1 = color1;
|
||||||
|
Color2 = color2;
|
||||||
|
Index = 0;
|
||||||
|
Direction = dir;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update the Fade Pattern
|
||||||
|
void NeoPatterns::FadeUpdate()
|
||||||
|
{
|
||||||
|
// Calculate linear interpolation between Color1 and Color2
|
||||||
|
// Optimise order of operations to minimize truncation error
|
||||||
|
uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / TotalSteps;
|
||||||
|
uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps;
|
||||||
|
uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps;
|
||||||
|
|
||||||
|
ColorSet(Color(red, green, blue));
|
||||||
|
show();
|
||||||
|
Increment();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::RandomFade(uint8_t interval ) {
|
||||||
|
ActivePattern = RANDOM_FADE;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = 255;
|
||||||
|
Index = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::RandomFadeUpdate() {
|
||||||
|
ColorSet(Wheel(Index));
|
||||||
|
Increment();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::RandomFadeSingle(uint8_t interval, uint8_t speed) {
|
||||||
|
ActivePattern = RANDOM_FADE_SINGLE;
|
||||||
|
Interval = interval;
|
||||||
|
TotalSteps = 255;
|
||||||
|
Index = 0;
|
||||||
|
WheelSpeed = speed;
|
||||||
|
RandomBuffer();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::RandomFadeSingleUpdate() {
|
||||||
|
for (int i = 0; i < numPixels(); i++) {
|
||||||
|
pixelR_buffer[i] += random(0, random(0, WheelSpeed + 1) + 1); //use buffer red channel for color wheel
|
||||||
|
setPixelColor(i, Wheel(pixelR_buffer[i]));
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
Increment();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::RandomBuffer()
|
||||||
|
{
|
||||||
|
for (int i = 0; i < numPixels(); i++) {
|
||||||
|
uint32_t c = Wheel(random(0, 256));
|
||||||
|
pixelR_buffer[i] = (uint8_t)(c >> 16);
|
||||||
|
pixelG_buffer[i] = (uint8_t)(c >> 8);
|
||||||
|
pixelB_buffer[i] = (uint8_t)c;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Random()
|
||||||
|
{
|
||||||
|
None(); // Stop all other effects
|
||||||
|
ActivePattern = RANDOM;
|
||||||
|
for (int i = 0; i < numPixels(); i++) {
|
||||||
|
setPixelColor(i, Wheel(random(0, 256)));
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::Smooth(uint8_t wheelSpeed, uint8_t smoothing, uint8_t strength, uint8_t interval) {
|
||||||
|
ActivePattern = SMOOTH;
|
||||||
|
Interval = interval;
|
||||||
|
Index = 0;
|
||||||
|
WheelSpeed = wheelSpeed;
|
||||||
|
Smoothing = smoothing;
|
||||||
|
Strength = strength;
|
||||||
|
movingPoint_x = 3;
|
||||||
|
movingPoint_y = 3;
|
||||||
|
// Clear buffer (from previous or different effects)
|
||||||
|
for (int i = 0; i < numPixels(); i++) {
|
||||||
|
pixelR_buffer[i] = 0;
|
||||||
|
pixelG_buffer[i] = 0;
|
||||||
|
pixelB_buffer[i] = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::SmoothUpdate() {
|
||||||
|
uint32_t c = Wheel(wPos);
|
||||||
|
wPosSlow += WheelSpeed;
|
||||||
|
wPos = (wPos + (wPosSlow / 10) ) % 255;
|
||||||
|
wPosSlow = wPosSlow % 16;
|
||||||
|
|
||||||
|
uint8_t r = (uint8_t)(c >> 16);
|
||||||
|
uint8_t g = (uint8_t)(c >> 8);
|
||||||
|
uint8_t b = (uint8_t)c;
|
||||||
|
|
||||||
|
movingPoint_x = movingPoint_x + 8 + random(-random(0, 1 + 1), random(0, 1 + 1) + 1);
|
||||||
|
movingPoint_y = movingPoint_y + 8 + random(-random(0, 1 + 1), random(0, 1 + 1) + 1);
|
||||||
|
if (movingPoint_x < 8) {
|
||||||
|
movingPoint_x = 8 - movingPoint_x;
|
||||||
|
} else if (movingPoint_x >= 16) {
|
||||||
|
movingPoint_x = 22 - movingPoint_x;
|
||||||
|
} else {
|
||||||
|
movingPoint_x -= 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (movingPoint_y < 8) {
|
||||||
|
movingPoint_y = 8 - movingPoint_y;
|
||||||
|
} else if (movingPoint_y >= 16) {
|
||||||
|
movingPoint_y = 22 - movingPoint_y;
|
||||||
|
} else {
|
||||||
|
movingPoint_y -= 8;
|
||||||
|
}
|
||||||
|
uint8_t startx = movingPoint_x;
|
||||||
|
uint8_t starty = movingPoint_y;
|
||||||
|
|
||||||
|
for (int i = 0; i < Strength; i++) {
|
||||||
|
|
||||||
|
movingPoint_x = startx + 8 + random(-random(0, 2 + 1), random(0, 2 + 1) + 1);
|
||||||
|
movingPoint_y = starty + 8 + random(-random(0, 2 + 1), random(0, 2 + 1) + 1);
|
||||||
|
|
||||||
|
if (movingPoint_x < 8) {
|
||||||
|
movingPoint_x = 8 - movingPoint_x;
|
||||||
|
} else if (movingPoint_x >= 16) {
|
||||||
|
movingPoint_x = 22 - movingPoint_x;
|
||||||
|
} else {
|
||||||
|
movingPoint_x -= 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (movingPoint_y < 8) {
|
||||||
|
movingPoint_y = 8 - movingPoint_y;
|
||||||
|
} else if (movingPoint_y >= 16) {
|
||||||
|
movingPoint_y = 22 - movingPoint_y;
|
||||||
|
} else {
|
||||||
|
movingPoint_y -= 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pixelR[xyToPos(movingPoint_x, movingPoint_y)] < r) {
|
||||||
|
pixelR[xyToPos(movingPoint_x, movingPoint_y)]++;
|
||||||
|
} else if (pixelR[xyToPos(movingPoint_x, movingPoint_y)] > r) {
|
||||||
|
pixelR[xyToPos(movingPoint_x, movingPoint_y)]--;
|
||||||
|
}
|
||||||
|
if (pixelG[xyToPos(movingPoint_x, movingPoint_y)] < g) {
|
||||||
|
pixelG[xyToPos(movingPoint_x, movingPoint_y)]++;
|
||||||
|
} else if (pixelG[xyToPos(movingPoint_x, movingPoint_y)] > g) {
|
||||||
|
pixelG[xyToPos(movingPoint_x, movingPoint_y)]--;
|
||||||
|
}
|
||||||
|
if (pixelB[xyToPos(movingPoint_x, movingPoint_y)] < b) {
|
||||||
|
pixelB[xyToPos(movingPoint_x, movingPoint_y)]++;
|
||||||
|
} else if (pixelB[xyToPos(movingPoint_x, movingPoint_y)] > b) {
|
||||||
|
pixelB[xyToPos(movingPoint_x, movingPoint_y)]--;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
movingPoint_x = startx;
|
||||||
|
movingPoint_y = starty;
|
||||||
|
|
||||||
|
for (int i = 0; i < numPixels(); i++) {
|
||||||
|
pixelR_buffer[i] = (Smoothing / 100.0) * pixelR[i] + (1.0 - (Smoothing / 100.0)) * getAverage(pixelR, i, 0, 0);
|
||||||
|
pixelG_buffer[i] = (Smoothing / 100.0) * pixelG[i] + (1.0 - (Smoothing / 100.0)) * getAverage(pixelG, i, 0, 0);
|
||||||
|
pixelB_buffer[i] = (Smoothing / 100.0) * pixelB[i] + (1.0 - (Smoothing / 100.0)) * getAverage(pixelB, i, 0, 0);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = 0; i < numPixels(); i++) {
|
||||||
|
pixelR[i] = pixelR_buffer[i];
|
||||||
|
pixelG[i] = pixelG_buffer[i];
|
||||||
|
pixelB[i] = pixelB_buffer[i];
|
||||||
|
setPixelColor(i, pixelR[i], pixelG[i], pixelB[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
show();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Based upon https://github.com/johncarl81/neopixelplasma
|
||||||
|
void NeoPatterns::Plasma(float phase, float phaseIncrement, float colorStretch, uint8_t interval)
|
||||||
|
{
|
||||||
|
ActivePattern = PLASMA;
|
||||||
|
Interval = interval;
|
||||||
|
PlasmaPhase = phase;
|
||||||
|
PlasmaPhaseIncrement = phaseIncrement;
|
||||||
|
PlasmaColorStretch = colorStretch;
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::PlasmaUpdate()
|
||||||
|
{
|
||||||
|
PlasmaPhase += PlasmaPhaseIncrement;
|
||||||
|
int edge = (int)sqrt(numPixels());
|
||||||
|
// The two points move along Lissajious curves, see: http://en.wikipedia.org/wiki/Lissajous_curve
|
||||||
|
// The sin() function returns values in the range of -1.0..1.0, so scale these to our desired ranges.
|
||||||
|
// The phase value is multiplied by various constants; I chose these semi-randomly, to produce a nice motion.
|
||||||
|
Point p1 = { (sin(PlasmaPhase * 1.000) + 1.0) * (edge / 2), (sin(PlasmaPhase * 1.310) + 1.0) * (edge / 2) };
|
||||||
|
Point p2 = { (sin(PlasmaPhase * 1.770) + 1.0) * (edge / 2), (sin(PlasmaPhase * 2.865) + 1.0) * (edge / 2) };
|
||||||
|
Point p3 = { (sin(PlasmaPhase * 0.250) + 1.0) * (edge / 2), (sin(PlasmaPhase * 0.750) + 1.0) * (edge / 2)};
|
||||||
|
|
||||||
|
byte row, col;
|
||||||
|
|
||||||
|
// For each row...
|
||||||
|
for ( row = 0; row < edge; row++ ) {
|
||||||
|
float row_f = float(row); // Optimization: Keep a floating point value of the row number, instead of recasting it repeatedly.
|
||||||
|
|
||||||
|
// For each column...
|
||||||
|
for ( col = 0; col < edge; col++ ) {
|
||||||
|
float col_f = float(col); // Optimization.
|
||||||
|
|
||||||
|
// Calculate the distance between this LED, and p1.
|
||||||
|
Point dist1 = { col_f - p1.x, row_f - p1.y }; // The vector from p1 to this LED.
|
||||||
|
float distance1 = sqrt( dist1.x * dist1.x + dist1.y * dist1.y );
|
||||||
|
|
||||||
|
// Calculate the distance between this LED, and p2.
|
||||||
|
Point dist2 = { col_f - p2.x, row_f - p2.y }; // The vector from p2 to this LED.
|
||||||
|
float distance2 = sqrt( dist2.x * dist2.x + dist2.y * dist2.y );
|
||||||
|
|
||||||
|
// Calculate the distance between this LED, and p3.
|
||||||
|
Point dist3 = { col_f - p3.x, row_f - p3.y }; // The vector from p3 to this LED.
|
||||||
|
float distance3 = sqrt( dist3.x * dist3.x + dist3.y * dist3.y );
|
||||||
|
|
||||||
|
// Warp the distance with a sin() function. As the distance value increases, the LEDs will get light,dark,light,dark,etc...
|
||||||
|
// You can use a cos() for slightly different shading, or experiment with other functions. Go crazy!
|
||||||
|
float color_1 = distance1; // range: 0.0...1.0
|
||||||
|
float color_2 = distance2;
|
||||||
|
float color_3 = distance3;
|
||||||
|
float color_4 = (sin( distance1 * distance2 * PlasmaColorStretch )) + 2.0 * 0.5;
|
||||||
|
|
||||||
|
// Square the color_f value to weight it towards 0. The image will be darker and have higher contrast.
|
||||||
|
color_1 *= color_1 * color_4;
|
||||||
|
color_2 *= color_2 * color_4;
|
||||||
|
color_3 *= color_3 * color_4;
|
||||||
|
color_4 *= color_4;
|
||||||
|
|
||||||
|
// Scale the color up to 0..7 . Max brightness is 7.
|
||||||
|
//strip.setPixelColor(col + (edge * row), strip.Color(color_4, 0, 0) );
|
||||||
|
|
||||||
|
setPixelColor(xyToPos(row, col), Color(color_1, color_2, color_3));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/****************** Helper functions ******************/
|
||||||
|
|
||||||
|
void NeoPatterns::SetColor1(uint32_t color) {
|
||||||
|
Color1 = color;
|
||||||
|
}
|
||||||
|
void NeoPatterns::SetColor2(uint32_t color) {
|
||||||
|
Color2 = color;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Calculate 50% dimmed version of a color (used by ScannerUpdate)
|
||||||
|
uint32_t NeoPatterns::DimColor(uint32_t color)
|
||||||
|
{
|
||||||
|
// Shift R, G and B components one bit to the right
|
||||||
|
uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1);
|
||||||
|
return dimColor;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set all pixels to a color (synchronously)
|
||||||
|
void NeoPatterns::ColorSet(uint32_t color)
|
||||||
|
{
|
||||||
|
for (int i = 0; i < numPixels(); i++)
|
||||||
|
{
|
||||||
|
setPixelColor(i, color);
|
||||||
|
}
|
||||||
|
show();
|
||||||
|
}
|
||||||
|
|
||||||
|
void NeoPatterns::ColorSetParameters(String parameters)
|
||||||
|
{
|
||||||
|
None();
|
||||||
|
ActivePattern = FILL;
|
||||||
|
ColorSet(parseColor(parameters));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the Red component of a 32-bit color
|
||||||
|
uint8_t NeoPatterns::Red(uint32_t color)
|
||||||
|
{
|
||||||
|
return (color >> 16) & 0xFF;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the Green component of a 32-bit color
|
||||||
|
uint8_t NeoPatterns::Green(uint32_t color)
|
||||||
|
{
|
||||||
|
return (color >> 8) & 0xFF;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the Blue component of a 32-bit color
|
||||||
|
uint8_t NeoPatterns::Blue(uint32_t color)
|
||||||
|
{
|
||||||
|
return color & 0xFF;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Input a value 0 to 255 to get a color value.
|
||||||
|
// The colors are a transition r - g - b - back to r.
|
||||||
|
uint32_t NeoPatterns::Wheel(byte WheelPos)
|
||||||
|
{
|
||||||
|
WheelPos = 255 - WheelPos;
|
||||||
|
if (WheelPos < 85)
|
||||||
|
{
|
||||||
|
return Color(255 - WheelPos * 3, 0, WheelPos * 3);
|
||||||
|
}
|
||||||
|
else if (WheelPos < 170)
|
||||||
|
{
|
||||||
|
WheelPos -= 85;
|
||||||
|
return Color(0, WheelPos * 3, 255 - WheelPos * 3);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
WheelPos -= 170;
|
||||||
|
return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Convert x y pixel position to matrix position
|
||||||
|
uint8_t NeoPatterns::xyToPos(int x, int y) {
|
||||||
|
if (y % 2 == 0) {
|
||||||
|
return (y * 8 + x);
|
||||||
|
} else {
|
||||||
|
return (y * 8 + (7 - x));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//convert pixel number to actual 8x8 matrix position
|
||||||
|
uint8_t NeoPatterns::numToPos(int num) {
|
||||||
|
int x = num % 8;
|
||||||
|
int y = num / 8;
|
||||||
|
return xyToPos(x, y);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Convert pixel number to actual 8x8 matrix position in a spiral
|
||||||
|
uint8_t NeoPatterns::numToSpiralPos(int num) {
|
||||||
|
int edge = (int)sqrt(numPixels());
|
||||||
|
int findx = edge - 1; // 7
|
||||||
|
int findy = 0;
|
||||||
|
int stepsize = edge - 1; // initial value (0..7)
|
||||||
|
int stepnumber = 0; // each "step" should be used twice
|
||||||
|
int count = -1;
|
||||||
|
int dir = 1; // direction: 0 = incX, 1=incY, 2=decX, 3=decY
|
||||||
|
if (num < edge) {
|
||||||
|
return num; // trivial
|
||||||
|
}
|
||||||
|
for (int i = edge; i <= num; i++)
|
||||||
|
{
|
||||||
|
count++;
|
||||||
|
if (count == stepsize) {
|
||||||
|
count = 0;
|
||||||
|
// Change direction
|
||||||
|
dir++;
|
||||||
|
stepnumber++;
|
||||||
|
if (stepnumber == 2) {
|
||||||
|
stepsize -= 1;
|
||||||
|
stepnumber = 0;
|
||||||
|
}
|
||||||
|
if (dir == 4) {
|
||||||
|
dir = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
switch (dir) {
|
||||||
|
case 0:
|
||||||
|
findx++;
|
||||||
|
break;
|
||||||
|
case 1:
|
||||||
|
findy++;
|
||||||
|
break;
|
||||||
|
case 2:
|
||||||
|
findx--;
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
findy--;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return xyToPos(findx, findy);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t NeoPatterns::getAverage(uint8_t array[], uint8_t i, int x, int y)
|
||||||
|
{
|
||||||
|
// TODO: This currently works only with 8x8 (64 pixel)!
|
||||||
|
uint16_t sum = 0;
|
||||||
|
uint8_t count = 0;
|
||||||
|
if (i >= 8) { //up
|
||||||
|
sum += array[i - 8];
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
if (i < (64 - 8)) { //down
|
||||||
|
sum += array[i + 8];
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
if (i >= 1) { //left
|
||||||
|
sum += array[i - 1];
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
if (i < (64 - 1)) { //right
|
||||||
|
sum += array[i + 1];
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
return sum / count;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t NeoPatterns::parseColor(String value) {
|
||||||
|
if (value.charAt(0) == '#') { //solid fill
|
||||||
|
String color = value.substring(1);
|
||||||
|
int number = (int) strtol( &color[0], NULL, 16);
|
||||||
|
// Split them up into r, g, b values
|
||||||
|
int r = number >> 16;
|
||||||
|
int g = number >> 8 & 0xFF;
|
||||||
|
int b = number & 0xFF;
|
||||||
|
return Color(r, g, b);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -0,0 +1,107 @@
|
||||||
|
#include <Adafruit_NeoPixel.h>
|
||||||
|
|
||||||
|
// Pattern types supported:
|
||||||
|
enum pattern { NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, RANDOM_FADE, SMOOTH, ICON, RANDOM_FADE_SINGLE, PLASMA, FILL, RANDOM };
|
||||||
|
// Patern directions supported:
|
||||||
|
enum direction { FORWARD, REVERSE };
|
||||||
|
|
||||||
|
class NeoPatterns : public Adafruit_NeoPixel
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type, void (*callback)());
|
||||||
|
|
||||||
|
void Update();
|
||||||
|
void Reverse();
|
||||||
|
void None(uint8_t interval = 40);
|
||||||
|
void Stop(uint8_t interval = 40);
|
||||||
|
void RainbowCycle(uint8_t interval, direction dir = FORWARD);
|
||||||
|
void RainbowCycleUpdate();
|
||||||
|
void TheaterChase(uint32_t color1, uint32_t color2, uint8_t interval, direction dir = FORWARD);
|
||||||
|
void TheaterChaseUpdate();
|
||||||
|
void ColorWipe(uint32_t color, uint8_t interval, direction dir = FORWARD);
|
||||||
|
void ColorWipeUpdate();
|
||||||
|
void Scanner(uint32_t color1 = 16711680, uint8_t interval = 40, bool colorful = false, bool spiral = false);
|
||||||
|
void ScannerUpdate();
|
||||||
|
void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD);
|
||||||
|
void FadeUpdate();
|
||||||
|
void RandomFade(uint8_t interval = 100);
|
||||||
|
void RandomFadeUpdate();
|
||||||
|
void RandomFadeSingle(uint8_t interval = 100, uint8_t speed = 5);
|
||||||
|
void RandomFadeSingleUpdate();
|
||||||
|
void RandomBuffer();
|
||||||
|
void Random();
|
||||||
|
void Smooth(uint8_t wheelSpeed = 16, uint8_t smoothing = 80, uint8_t strength = 50, uint8_t interval = 40);
|
||||||
|
void SmoothUpdate();
|
||||||
|
void Plasma(float phase = 0, float phaseIncrement = 0.08, float colorStretch = 0.11, uint8_t interval = 60); // 0.08 and 0.11 // 0.03 und 0.3
|
||||||
|
void PlasmaUpdate();
|
||||||
|
|
||||||
|
void SetColor1(uint32_t color);
|
||||||
|
void SetColor2(uint32_t color);
|
||||||
|
//Utilities
|
||||||
|
void ColorSet(uint32_t color);
|
||||||
|
void ColorSetParameters(String parameters);
|
||||||
|
uint8_t Red(uint32_t color);
|
||||||
|
uint8_t Green(uint32_t color);
|
||||||
|
uint8_t Blue(uint32_t color);
|
||||||
|
uint32_t Wheel(byte WheelPos);
|
||||||
|
uint8_t numToSpiralPos(int num);
|
||||||
|
uint8_t xyToPos(int x, int y);
|
||||||
|
uint8_t numToPos(int num);
|
||||||
|
uint8_t getAverage(uint8_t array[], uint8_t i, int x, int y);
|
||||||
|
uint32_t parseColor(String value);
|
||||||
|
private:
|
||||||
|
|
||||||
|
// Member Variables:
|
||||||
|
pattern ActivePattern; // which pattern is running
|
||||||
|
pattern SavedPattern;
|
||||||
|
direction Direction; // direction to run the pattern
|
||||||
|
direction SavedDirection;
|
||||||
|
|
||||||
|
unsigned long Interval; // milliseconds between updates
|
||||||
|
unsigned long SavedInterval;
|
||||||
|
unsigned long lastUpdate; // last update of position
|
||||||
|
|
||||||
|
uint32_t Color1, Color2; // What colors are in use
|
||||||
|
uint32_t SavedColor1;
|
||||||
|
uint16_t TotalSteps; // total number of steps in the pattern
|
||||||
|
uint16_t SavedTotalSteps;
|
||||||
|
uint16_t Index; // current step within the pattern
|
||||||
|
uint16_t SavedIndex;
|
||||||
|
uint8_t Every; // Turn every "Every" pixel in Color1/Color2
|
||||||
|
|
||||||
|
byte wPos;
|
||||||
|
bool colorful;
|
||||||
|
bool spiral;
|
||||||
|
uint8_t wPosSlow;
|
||||||
|
uint8_t WheelSpeed;
|
||||||
|
uint8_t Smoothing;
|
||||||
|
uint8_t Strength;
|
||||||
|
uint8_t movingPoint_x;
|
||||||
|
uint8_t movingPoint_y;
|
||||||
|
uint8_t *pixelR;
|
||||||
|
uint8_t *pixelG;
|
||||||
|
uint8_t *pixelB;
|
||||||
|
uint8_t *pixelR_buffer;
|
||||||
|
uint8_t *pixelG_buffer;
|
||||||
|
uint8_t *pixelB_buffer;
|
||||||
|
|
||||||
|
float PlasmaPhase;
|
||||||
|
float SavedPlasmaPhase;
|
||||||
|
float PlasmaPhaseIncrement;
|
||||||
|
float SavedPlasmaPhaseIncrement;
|
||||||
|
float PlasmaColorStretch;
|
||||||
|
float SavedPlasmaColorStretch;
|
||||||
|
|
||||||
|
|
||||||
|
uint32_t DimColor(uint32_t color);
|
||||||
|
void Increment();
|
||||||
|
void (*OnComplete)(); // Callback on completion of pattern
|
||||||
|
|
||||||
|
// Convenient 2D point structure
|
||||||
|
struct Point {
|
||||||
|
float x;
|
||||||
|
float y;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
};
|
||||||
|
|
@ -2,6 +2,14 @@
|
||||||
#include <ArduinoOTA.h>
|
#include <ArduinoOTA.h>
|
||||||
#include <Arduino.h>
|
#include <Arduino.h>
|
||||||
#include <SoftwareSerial.h>
|
#include <SoftwareSerial.h>
|
||||||
|
#include "NeoPatterns.h"
|
||||||
|
|
||||||
|
#define PIN D6
|
||||||
|
#define NUMPIXELS 81
|
||||||
|
|
||||||
|
NeoPatterns strip = NeoPatterns(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ400, &StripComplete);
|
||||||
|
// NeoPatterns strip = NeoPatterns(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ400, &StripComplete);
|
||||||
|
HomieNode homieNode("pixel", "commands");
|
||||||
|
|
||||||
// Timeout, wann die Verbindung als "zurückgesetzt" angesehen werden soll und wieder auf das erste Byte gewartet wird
|
// Timeout, wann die Verbindung als "zurückgesetzt" angesehen werden soll und wieder auf das erste Byte gewartet wird
|
||||||
#define TIMEOUT 500
|
#define TIMEOUT 500
|
||||||
|
|
@ -18,6 +26,155 @@ String output2 = "";
|
||||||
|
|
||||||
HomieNode switchNode("switch", "switch");
|
HomieNode switchNode("switch", "switch");
|
||||||
|
|
||||||
|
void StripComplete(){
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetColor(const HomieRange& range, const String& value) {
|
||||||
|
if (!range.isRange || range.index < 0 || range.index > 1) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
switch (range.index) {
|
||||||
|
case 0:
|
||||||
|
strip.SetColor1(value.toInt());
|
||||||
|
break;
|
||||||
|
case 1:
|
||||||
|
strip.SetColor2(value.toInt());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
homieNode.setProperty("color_" + String(range.index)).send(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetPixel(const HomieRange& range, const String& value) {
|
||||||
|
if (!range.isRange) {
|
||||||
|
strip.None();
|
||||||
|
strip.ColorSet(value.toInt());
|
||||||
|
homieNode.setProperty("pixel").send(value);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
if (range.index < 0 || range.index > strip.numPixels() - 1) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
strip.None();
|
||||||
|
strip.setPixelColor(range.index, value.toInt());
|
||||||
|
strip.show();
|
||||||
|
homieNode.setProperty("pixel_" + String(range.index)).send(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetBrightness(const HomieRange& range, const String& value) {
|
||||||
|
long brightness = value.toInt();
|
||||||
|
if (brightness < 0 || brightness > 255) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
strip.setBrightness(brightness);
|
||||||
|
strip.show();
|
||||||
|
homieNode.setProperty("brightness").send(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetPixels(const HomieRange& range, const String& value) {
|
||||||
|
|
||||||
|
String remaining = value;
|
||||||
|
int i = 0;
|
||||||
|
// Kein Effekt
|
||||||
|
strip.Stop();
|
||||||
|
do {
|
||||||
|
String current = remaining.substring(0, 7);
|
||||||
|
Homie.getLogger() << i << ":" << current << endl;
|
||||||
|
uint32_t currentcolor = strip.parseColor(current);
|
||||||
|
|
||||||
|
strip.setPixelColor(strip.numToPos(i), currentcolor);
|
||||||
|
i++;
|
||||||
|
|
||||||
|
remaining = remaining.substring(7);
|
||||||
|
|
||||||
|
} while (remaining.length() > 2 && (i < strip.numPixels()));
|
||||||
|
Homie.getLogger() << " filling rest with black" << endl;
|
||||||
|
while (i < strip.numPixels()) {
|
||||||
|
strip.setPixelColor(strip.numToPos(i), strip.Color(0, 0, 0));
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
strip.show();
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetEffect(const HomieRange& range, const String& value) {
|
||||||
|
String effect = value;
|
||||||
|
effect.toLowerCase();
|
||||||
|
if (effect == "scanner") {
|
||||||
|
strip.Scanner(strip.Color(255, 0, 0));
|
||||||
|
}
|
||||||
|
else if (effect == "randomscanner") {
|
||||||
|
strip.Scanner(strip.Color(255, 0, 0), 40, true);
|
||||||
|
}
|
||||||
|
else if (effect == "larsonspiral") {
|
||||||
|
strip.Scanner(strip.Color(255, 0, 0), 40, true, true);
|
||||||
|
}
|
||||||
|
else if (effect == "rainbowcycle") {
|
||||||
|
strip.RainbowCycle(50);
|
||||||
|
}
|
||||||
|
else if (effect == "theaterchase" || effect == "chase") {
|
||||||
|
strip.TheaterChase(strip.Color(255, 0, 0), strip.Color(0, 0, 255), 100);
|
||||||
|
}
|
||||||
|
else if (effect == "fade") {
|
||||||
|
strip.Fade(strip.Color(255, 0, 0), strip.Color(0, 0, 255), 200, 100);
|
||||||
|
}
|
||||||
|
else if (effect == "randomfade") {
|
||||||
|
strip.RandomFade();
|
||||||
|
}
|
||||||
|
else if (effect == "random") {
|
||||||
|
strip.Random();
|
||||||
|
}
|
||||||
|
else if (effect == "smooth") { //example: smooth|[wheelspeed]|[smoothing]|[strength] wheelspeed=1-255, smoothing=0-100, strength=1-255
|
||||||
|
strip.Smooth(16, 80, 50, 40);
|
||||||
|
}
|
||||||
|
else if (effect == "plasma") {
|
||||||
|
strip.Plasma();
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// Test whether command with parameters was sent
|
||||||
|
int sep = value.indexOf("|");
|
||||||
|
String command = value.substring(0, sep);
|
||||||
|
String parameters = value.substring(sep + 1);
|
||||||
|
if (command.equals("fill")) {
|
||||||
|
strip.ColorSetParameters(parameters);
|
||||||
|
}
|
||||||
|
else if (command.equals("randomfade")) {
|
||||||
|
int sepparam = parameters.indexOf("|");
|
||||||
|
int p1 = parameters.substring(0, sepparam).toInt();
|
||||||
|
if (p1 <= 0) {
|
||||||
|
p1 = 5;
|
||||||
|
}
|
||||||
|
strip.RandomFadeSingle(p1);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
strip.None();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
homieNode.setProperty("effect").send(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetClear(const HomieRange& range, const String& value) {
|
||||||
|
strip.None();
|
||||||
|
strip.clear();
|
||||||
|
strip.show();
|
||||||
|
homieNode.setProperty("clear").send(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool onSetLength(const HomieRange& range, const String& value) {
|
||||||
|
strip.None();
|
||||||
|
strip.clear();
|
||||||
|
strip.show();
|
||||||
|
int newLength = value.toInt();
|
||||||
|
if (newLength > 0) {
|
||||||
|
strip.updateLength(newLength);
|
||||||
|
}
|
||||||
|
homieNode.setProperty("length").send(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
bool switchHandler(const HomieRange& range, const String& value) {
|
bool switchHandler(const HomieRange& range, const String& value) {
|
||||||
Homie.getLogger() << "switch " << ": " << value << endl;
|
Homie.getLogger() << "switch " << ": " << value << endl;
|
||||||
int localByte = 0;
|
int localByte = 0;
|
||||||
|
|
@ -56,6 +213,11 @@ bool switchHandler(const HomieRange& range, const String& value) {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void loopHandler() {
|
||||||
|
strip.Update();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
void setup() {
|
void setup() {
|
||||||
Serial.begin(115200);
|
Serial.begin(115200);
|
||||||
swSer.begin(9600);
|
swSer.begin(9600);
|
||||||
|
|
@ -64,10 +226,25 @@ void setup() {
|
||||||
Homie_setFirmware(FW_NAME, FW_VERSION);
|
Homie_setFirmware(FW_NAME, FW_VERSION);
|
||||||
Homie_setBrand(FW_NAME);
|
Homie_setBrand(FW_NAME);
|
||||||
|
|
||||||
|
Homie.setLoopFunction(loopHandler);
|
||||||
|
|
||||||
switchNode.advertise("switch").settable(switchHandler);
|
switchNode.advertise("switch").settable(switchHandler);
|
||||||
|
|
||||||
|
homieNode.advertiseRange("pixel", 0, NUMPIXELS - 1).settable(onSetPixel);
|
||||||
|
homieNode.advertiseRange("color", 0, 1).settable(onSetColor);
|
||||||
|
homieNode.advertise("brightness").settable(onSetBrightness);
|
||||||
|
homieNode.advertise("effect").settable(onSetEffect);
|
||||||
|
homieNode.advertise("clear").settable(onSetClear);
|
||||||
|
homieNode.advertise("length").settable(onSetLength);
|
||||||
|
homieNode.advertiseRange("pixels", 0, (NUMPIXELS - 1)*7).settable(onSetPixels);
|
||||||
|
|
||||||
|
|
||||||
Homie.setup();
|
Homie.setup();
|
||||||
|
|
||||||
|
strip.begin();
|
||||||
|
strip.clear();
|
||||||
|
strip.show();
|
||||||
|
|
||||||
ArduinoOTA.setHostname(Homie.getConfiguration().deviceId);
|
ArduinoOTA.setHostname(Homie.getConfiguration().deviceId);
|
||||||
ArduinoOTA.begin();
|
ArduinoOTA.begin();
|
||||||
}
|
}
|
||||||
|
|
@ -75,7 +252,7 @@ void setup() {
|
||||||
void loop() {
|
void loop() {
|
||||||
Homie.loop();
|
Homie.loop();
|
||||||
ArduinoOTA.handle();
|
ArduinoOTA.handle();
|
||||||
|
|
||||||
while (swSer.available() > 0) {
|
while (swSer.available() > 0) {
|
||||||
int r1 = swSer.read();
|
int r1 = swSer.read();
|
||||||
Serial.print(currentnumber);
|
Serial.print(currentnumber);
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue