704 lines
17 KiB
C++
704 lines
17 KiB
C++
|
/*-------------------------------------------------------------------------
|
||
|
|
Arduino library to provide a variety of effects when using Adafruit's
|
||
|
|
NeoPixel library along with NeoPixels and other compatible hardware.
|
||
|
|
This library is a work in progress and it's main purpose to help get
|
||
|
|
my coding back on track after a long absence. Wish me luck!
|
||
|
|
Written by Nolan Moore.
|
||
|
|
-------------------------------------------------------------------------
|
||
|
|
This file is part of the NeoPixel Effects library.
|
||
|
|
NeoPixel is free software: you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU Lesser General Public License as
|
||
|
|
published by the Free Software Foundation, either version 3 of
|
||
|
|
the License, or (at your option) any later version.
|
||
|
|
NeoPixel is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU Lesser General Public License for more details.
|
||
|
|
You should have received a copy of the GNU Lesser General Public
|
||
|
|
License along with NeoPixel. If not, see
|
||
|
|
<http://www.gnu.org/licenses/>.
|
||
|
|
-------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
#include <NeoPixelEffects.h>
|
||
|
|
|
||
|
|
NeoPixelEffects::NeoPixelEffects(CRGB *ledset, Effect effect, int pixstart, int pixend, int aoe, unsigned long delay, CRGB color_crgb, bool repeat, bool dir) :
|
||
|
|
_pixset(ledset), _color_fg(color_crgb), _color_bg(CRGB::Black), _repeat(repeat), _direction(dir), _counter(0)
|
||
|
|
{
|
||
|
|
setRange(pixstart, pixend);
|
||
|
|
setAreaOfEffect(aoe);
|
||
|
|
setDelay(delay);
|
||
|
|
setEffect(effect);
|
||
|
|
// *assoc_effects = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
NeoPixelEffects::NeoPixelEffects()
|
||
|
|
{
|
||
|
|
*_pixset = NULL;
|
||
|
|
_effect = NONE;
|
||
|
|
_status = INACTIVE;
|
||
|
|
_pixstart = 0;
|
||
|
|
_pixend = 0;
|
||
|
|
_pixrange = 1;
|
||
|
|
_pixaoe = 1;
|
||
|
|
_pixcurrent = _pixstart;
|
||
|
|
_counter = 0;
|
||
|
|
_delay = 0;
|
||
|
|
_lastupdate = 0;
|
||
|
|
_color_fg = CRGB::Black;
|
||
|
|
_color_bg = CRGB::Black;
|
||
|
|
_repeat = true;
|
||
|
|
_direction = FORWARD;
|
||
|
|
}
|
||
|
|
|
||
|
|
NeoPixelEffects::~NeoPixelEffects()
|
||
|
|
{
|
||
|
|
*_pixset = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setEffect(Effect effect)
|
||
|
|
{
|
||
|
|
_effect = effect;
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
_pixcurrent = _pixstart;
|
||
|
|
_counter = 0;
|
||
|
|
} else {
|
||
|
|
_pixcurrent = _pixend;
|
||
|
|
_counter = 100;
|
||
|
|
if (effect == TALKING) {
|
||
|
|
_counter = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_lastupdate = 0;
|
||
|
|
_status = ACTIVE;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::update()
|
||
|
|
{
|
||
|
|
if (_status == ACTIVE) {
|
||
|
|
unsigned long now = millis();
|
||
|
|
if (now - _lastupdate > _delay) {
|
||
|
|
_lastupdate = now;
|
||
|
|
switch (_effect) {
|
||
|
|
case COMET:
|
||
|
|
updateCometEffect(0);
|
||
|
|
break;
|
||
|
|
case LARSON:
|
||
|
|
updateCometEffect(1);
|
||
|
|
break;
|
||
|
|
case CHASE:
|
||
|
|
updateChaseEffect();
|
||
|
|
break;
|
||
|
|
case PULSE:
|
||
|
|
updatePulseEffect();
|
||
|
|
break;
|
||
|
|
case STATIC:
|
||
|
|
updateStaticEffect(0);
|
||
|
|
break;
|
||
|
|
case RANDOM:
|
||
|
|
updateStaticEffect(1);
|
||
|
|
break;
|
||
|
|
case FADE:
|
||
|
|
updateFadeOutEffect();
|
||
|
|
break;
|
||
|
|
case FILLIN:
|
||
|
|
updateFillInEffect();
|
||
|
|
break;
|
||
|
|
case GLOW:
|
||
|
|
updateGlowEffect();
|
||
|
|
break;
|
||
|
|
case RAINBOWWAVE:
|
||
|
|
updateRainbowWaveEffect();
|
||
|
|
break;
|
||
|
|
case STROBE:
|
||
|
|
updateStrobeEffect();
|
||
|
|
break;
|
||
|
|
case SINEWAVE:
|
||
|
|
updateWaveEffect(0);
|
||
|
|
break;
|
||
|
|
case TRIWAVE:
|
||
|
|
updateWaveEffect(1);
|
||
|
|
break;
|
||
|
|
case TALKING:
|
||
|
|
updateTalkingEffect();
|
||
|
|
break;
|
||
|
|
// case FIREWORK:
|
||
|
|
// updateFireworkEffect();
|
||
|
|
// break;
|
||
|
|
// case SPARKLEFILL:
|
||
|
|
// updateSparkleFillEffect();
|
||
|
|
// break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateCometEffect(int subtype)
|
||
|
|
{
|
||
|
|
if (subtype > 0) {
|
||
|
|
if (_repeat) _repeat = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int j = 0; j <= _pixaoe; j++) {
|
||
|
|
int tpx;
|
||
|
|
bool showpix = true;
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
tpx = _pixcurrent + j;
|
||
|
|
if (tpx > _pixend) {
|
||
|
|
if (_repeat) {
|
||
|
|
tpx = _pixcurrent + j - _pixrange + 1;
|
||
|
|
} else {
|
||
|
|
showpix = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
tpx = _pixcurrent - j;
|
||
|
|
if (tpx < _pixstart) {
|
||
|
|
if (_repeat) {
|
||
|
|
tpx = _pixcurrent - j + _pixrange;
|
||
|
|
} else {
|
||
|
|
showpix = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (showpix) {
|
||
|
|
float ratio = j / (float)_pixaoe;
|
||
|
|
CRGB tailcolor = CRGB(_color_fg.r * ratio, _color_fg.g * ratio, _color_fg.b * ratio);
|
||
|
|
|
||
|
|
_pixset[tpx] = tailcolor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
if (_pixcurrent == _pixend) {
|
||
|
|
if (_repeat) {
|
||
|
|
_pixcurrent = _pixstart;
|
||
|
|
} else {
|
||
|
|
if (subtype > 0) {
|
||
|
|
_direction = REVERSE;
|
||
|
|
} else {
|
||
|
|
stop();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
_pixcurrent++;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (_pixcurrent == _pixstart) {
|
||
|
|
if (_repeat) {
|
||
|
|
_pixcurrent = _pixend;
|
||
|
|
} else {
|
||
|
|
if (subtype > 0) {
|
||
|
|
_direction = FORWARD;
|
||
|
|
} else {
|
||
|
|
stop();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
_pixcurrent--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateChaseEffect()
|
||
|
|
{
|
||
|
|
for (int j = _pixstart; j <= _pixend; j++) {
|
||
|
|
if (_counter % 2 == 0) {
|
||
|
|
if (j % 2 == 0) {
|
||
|
|
_pixset[j] = _color_fg;
|
||
|
|
} else {
|
||
|
|
_pixset[j] = _color_bg;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (j % 2 == 0) {
|
||
|
|
_pixset[j] = _color_bg;
|
||
|
|
} else {
|
||
|
|
_pixset[j] = _color_fg;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_counter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateStrobeEffect()
|
||
|
|
{
|
||
|
|
CRGB strobecolor;
|
||
|
|
if (_counter % 2 == 0) {
|
||
|
|
strobecolor = _color_fg;
|
||
|
|
} else {
|
||
|
|
strobecolor = _color_bg;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int j = _pixstart; j <= _pixend; j++) {
|
||
|
|
_pixset[j] = strobecolor;
|
||
|
|
}
|
||
|
|
_counter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateStaticEffect(int subtype)
|
||
|
|
{
|
||
|
|
random16_add_entropy(random(65535));
|
||
|
|
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
CRGB randomcolor;
|
||
|
|
if (subtype == 0) {
|
||
|
|
float random_ratio = random8(101) / 100.0;
|
||
|
|
randomcolor.r = _color_fg.r * random_ratio;
|
||
|
|
randomcolor.g = _color_fg.g * random_ratio;
|
||
|
|
randomcolor.b = _color_fg.b * random_ratio;
|
||
|
|
} else {
|
||
|
|
randomcolor.r = 255 * random8(101) / 100.0;
|
||
|
|
randomcolor.g = 255 * random8(101) / 100.0;
|
||
|
|
randomcolor.b = 255 * random8(101) / 100.0;
|
||
|
|
}
|
||
|
|
_pixset[i] = randomcolor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateFadeOutEffect()
|
||
|
|
{
|
||
|
|
if (_counter == 0) _counter = 100;
|
||
|
|
float ratio = _counter / 100.0;
|
||
|
|
|
||
|
|
CRGB fadecolor;
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
fadecolor = CRGB(_pixset[i].r * ratio, _pixset[i].g * ratio, _pixset[i].b * ratio);
|
||
|
|
_pixset[i] = fadecolor;
|
||
|
|
}
|
||
|
|
|
||
|
|
_counter--;
|
||
|
|
|
||
|
|
if (_counter <= 0 || fadecolor == CRGB(0,0,0)) {
|
||
|
|
pause();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateFillInEffect()
|
||
|
|
{
|
||
|
|
_pixset[_pixcurrent] = _color_fg;
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
if (_pixcurrent != _pixend) {
|
||
|
|
_pixcurrent++;
|
||
|
|
} else {
|
||
|
|
pause();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (_pixcurrent != _pixstart) {
|
||
|
|
_pixcurrent--;
|
||
|
|
} else {
|
||
|
|
pause();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateGlowEffect()
|
||
|
|
{
|
||
|
|
// Ensure glow_area_half is always even
|
||
|
|
if (_pixrange % 2 == 0 && _pixaoe % 2 != 0) {
|
||
|
|
_pixaoe++;
|
||
|
|
} else if (_pixrange % 2 != 0 && _pixaoe % 2 == 0) {
|
||
|
|
_pixaoe--;
|
||
|
|
}
|
||
|
|
|
||
|
|
float ratio = _counter / 100.0;
|
||
|
|
CRGB glowcolor;
|
||
|
|
glowcolor.r = _color_fg.r * ratio;
|
||
|
|
glowcolor.g = _color_fg.g * ratio;
|
||
|
|
glowcolor.b = _color_fg.b * ratio;
|
||
|
|
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
_counter++;
|
||
|
|
if (_counter >= 100) _direction = REVERSE;
|
||
|
|
} else {
|
||
|
|
_counter--;
|
||
|
|
if (_counter <= 0) {
|
||
|
|
_direction = FORWARD;
|
||
|
|
if (!_repeat) {
|
||
|
|
pause();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int glow_area_half = (_pixrange - _pixaoe) / 2;
|
||
|
|
for (int i = 0; i < glow_area_half ; i++) {
|
||
|
|
uint8_t denom = glow_area_half + 1 - i;
|
||
|
|
CRGB tempcolor = CRGB(glowcolor.r / denom, glowcolor.g / denom, glowcolor.b / denom);
|
||
|
|
_pixset[_pixstart + i] = tempcolor;
|
||
|
|
_pixset[_pixend - i] = tempcolor;
|
||
|
|
}
|
||
|
|
for (int i = 0; i < _pixaoe; i++) {
|
||
|
|
_pixset[_pixstart + glow_area_half + i] = glowcolor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updatePulseEffect()
|
||
|
|
{
|
||
|
|
CRGB pulsecolor;
|
||
|
|
|
||
|
|
float ratio = _counter / 100.0;
|
||
|
|
pulsecolor.r = _color_fg.r * ratio;
|
||
|
|
pulsecolor.g = _color_fg.g * ratio;
|
||
|
|
pulsecolor.b = _color_fg.b * ratio;
|
||
|
|
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
_counter++;
|
||
|
|
if (_counter >= 100) _direction = REVERSE;
|
||
|
|
} else {
|
||
|
|
_counter--;
|
||
|
|
if (_counter <= 0) _direction = FORWARD;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
_pixset[i] = pulsecolor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// void NeoPixelEffects::updateFireworkEffect()
|
||
|
|
// {
|
||
|
|
// static NeoPixelEffects *m = new NeoPixelEffects(_pixset, COMET, _pixstart, _pixend - _pixaoe - 4, 2, 25, CRGB::White, false, FORWARD);
|
||
|
|
// static NeoPixelEffects *s1 = new NeoPixelEffects(_pixset, NONE, _pixend - 2 * _pixaoe - 4, _pixend - _pixaoe - 2, stars_aoe, _delay, _color_fg, false, REVERSE);
|
||
|
|
// static NeoPixelEffects *s2 = new NeoPixelEffects(_pixset, NONE, _pixend - _pixaoe - 2, stars_end, stars_aoe, _delay, _color_fg, false, FORWARD);
|
||
|
|
// static NeoPixelEffects *sf = new NeoPixelEffects(_pixset, NONE, _pixend - 2 * _pixaoe - 4, _pixend, 1, 7, _color_fg, false, REVERSE);
|
||
|
|
//
|
||
|
|
// if (_counter == 0 && m->getEffect() == NONE) {
|
||
|
|
// delay(200);
|
||
|
|
// s1->setEffect(FILLIN);
|
||
|
|
// s2->setEffect(FILLIN);
|
||
|
|
// _counter = 1;
|
||
|
|
// } else if (_counter == 1 && s1->getEffect() == NONE && s2->getEffect() == NONE) {
|
||
|
|
// delay(200);
|
||
|
|
// sf->setEffect(FADE);
|
||
|
|
// _counter = 2;
|
||
|
|
// } else if (_counter == 2 && sf->getEffect() == NONE) {
|
||
|
|
// delete(m);
|
||
|
|
// delete(s1);
|
||
|
|
// delete(s2);
|
||
|
|
// delete(sf);
|
||
|
|
// setEffect(NONE);
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// m->update();
|
||
|
|
// s1->update();
|
||
|
|
// s2->update();
|
||
|
|
// sf->update();
|
||
|
|
// }
|
||
|
|
|
||
|
|
// void NeoPixelEffects::updateSparkleFillEffect()
|
||
|
|
// {
|
||
|
|
// static NeoPixelEffects *sparkles = new NeoPixelEffects(_pixset, STATIC, (_direction==FORWARD)?_pixstart, (_direction==FORWARD)?_pixstart:_pixend, 1, _delay, _color_fg, false, _direction);
|
||
|
|
//
|
||
|
|
// sparkles->update();
|
||
|
|
//
|
||
|
|
// if (_direction == FORWARD) {
|
||
|
|
// if (_pixcurrent != _pixend) {
|
||
|
|
// _pixcurrent++;
|
||
|
|
// sparkles->setRange(_pixstart, _pixcurrent);
|
||
|
|
// }
|
||
|
|
// } else {
|
||
|
|
// if (_pixcurrent != _pixstart) {
|
||
|
|
// _pixcurrent--;
|
||
|
|
// sparkles->setRange(_pixcurrent, _pixend);
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if (_status == INACTIVE) {
|
||
|
|
// delete(sparkles);
|
||
|
|
// clear();
|
||
|
|
// setEffect(NONE);
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateRainbowWaveEffect()
|
||
|
|
{
|
||
|
|
float ratio = 255.0 / _pixrange;
|
||
|
|
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
CRGB color = CHSV((uint8_t)((_counter + i) * ratio), 255, 255);
|
||
|
|
_pixset[i] = color;
|
||
|
|
}
|
||
|
|
_counter = (_direction) ? _counter + 1 : _counter - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateWaveEffect(int subtype)
|
||
|
|
{
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
float ratio;
|
||
|
|
if (!subtype) {
|
||
|
|
ratio = cubicwave8((255 * (i - _pixstart) / _pixrange) + _counter) / 255.0;
|
||
|
|
} else {
|
||
|
|
ratio = triwave8((255 * (i - _pixstart) / _pixrange) + _counter) / 255.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
CRGB wavecolor = CRGB(_color_fg.r * ratio, _color_fg.g * ratio, _color_fg.b * ratio);
|
||
|
|
_pixset[i] = wavecolor;
|
||
|
|
}
|
||
|
|
_counter = (_direction) ? _counter + 2 : _counter - 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
// void NeoPixelEffects::updateTalkingEffectV2()
|
||
|
|
// {
|
||
|
|
// static uint8_t init = 1;
|
||
|
|
// static uint8_t next_bright = 0;
|
||
|
|
// static uint16_t next_delay = 0;
|
||
|
|
// static unsigned long lastupdate = 0;
|
||
|
|
// static uint8_t max_b = 0;
|
||
|
|
// static uint8_t min_b = 0;
|
||
|
|
// static uint8_t current_b = 0;
|
||
|
|
// static int delta_b = 0;
|
||
|
|
//
|
||
|
|
// if (init) {
|
||
|
|
// initTalkingEffect(next_bright, next_delay, max_b, min_b, current_b);
|
||
|
|
// init = 0;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// unsigned long now = millis();
|
||
|
|
//
|
||
|
|
// if (now - lastupdate > next_delay) {
|
||
|
|
// // Updater delay and brightness
|
||
|
|
// lastupdate = now;
|
||
|
|
// next_delay = random16(100, 250);
|
||
|
|
// next_bright = random8(min_b + 50, max_b);
|
||
|
|
//
|
||
|
|
// // Even if we are currently moving down slope, make sure next brightness is higher
|
||
|
|
// while (next_bright - current_b <= 0) {
|
||
|
|
// next_bright = random8(min_b + 50, max_b);
|
||
|
|
// }
|
||
|
|
// delta_b = next_bright - current_b;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if (delta_b > 0) {
|
||
|
|
// if (_direction == FORWARD) {
|
||
|
|
// current_b++;
|
||
|
|
// delta_b = next_bright - current_b;
|
||
|
|
// } else {
|
||
|
|
// current_b--;
|
||
|
|
// delta_b = current_b - min_b;
|
||
|
|
// }
|
||
|
|
// } else {
|
||
|
|
// if (current_b == next_bright) {
|
||
|
|
// _direction = REVERSE;
|
||
|
|
// delta_b = current_b - min_b;
|
||
|
|
// } else {
|
||
|
|
// _direction = FORWARD;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// // Set colors
|
||
|
|
// float ratio = current_b / 255.0;
|
||
|
|
// CRGB pulsecolor = CRGB(_color_fg.r * ratio, _color_fg.g * ratio, _color_fg.b * ratio);
|
||
|
|
// for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
// _pixset[i] = pulsecolor;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// void NeoPixelEffects::initTalkingEffectV2(uint8_t &bright, uint16_t &delay, uint8_t &maxb, uint8_t &minb, uint8_t &nowb)
|
||
|
|
// {
|
||
|
|
// maxb = max(_color_fg.r, max(_color_fg.g, _color_fg.b));
|
||
|
|
// minb = _color_bg.r;
|
||
|
|
// nowb = minb;
|
||
|
|
// _direction = FORWARD;
|
||
|
|
// _delay = 0;
|
||
|
|
// _color_bg = CRGB(30, 0, 0);
|
||
|
|
//
|
||
|
|
// bright = random8(minb + 50, maxb);
|
||
|
|
// delay = random16(100, 250);
|
||
|
|
// }
|
||
|
|
|
||
|
|
void NeoPixelEffects::updateTalkingEffect()
|
||
|
|
{
|
||
|
|
// Minimum 6 range
|
||
|
|
static uint8_t init = 1;
|
||
|
|
static uint8_t target_pix = 0;
|
||
|
|
static uint16_t next_update = 0;
|
||
|
|
static unsigned long lastupdate = 0;
|
||
|
|
|
||
|
|
if (init) {
|
||
|
|
_pixaoe = 3;
|
||
|
|
_counter = 0;
|
||
|
|
_direction = FORWARD;
|
||
|
|
init = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned long now = millis();
|
||
|
|
|
||
|
|
if (now - lastupdate > next_update) {
|
||
|
|
lastupdate = now;
|
||
|
|
next_update = random16(150, 450); // About the min and max time between syllables
|
||
|
|
target_pix = random8(_pixaoe, _pixrange / 2);
|
||
|
|
_direction = (target_pix > _counter) ? FORWARD : REVERSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_counter != target_pix) {
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
_counter++;
|
||
|
|
} else {
|
||
|
|
_counter--;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (target_pix != 0) {
|
||
|
|
target_pix = 0;
|
||
|
|
_direction = REVERSE;
|
||
|
|
} else {
|
||
|
|
if (_direction == REVERSE) {
|
||
|
|
_direction = FORWARD;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
clear();
|
||
|
|
if (_counter != 0) {
|
||
|
|
if (_pixrange % 2 != 0) {
|
||
|
|
_pixset[_pixstart + _pixrange / 2] = _color_fg;
|
||
|
|
}
|
||
|
|
for (int i = 0; i < _counter; i++) {
|
||
|
|
_pixset[_pixstart + (_pixrange / 2) - 1 - i] = _color_fg;
|
||
|
|
if (_pixrange % 2 == 0) {
|
||
|
|
_pixset[_pixstart + (_pixrange / 2) + i] = _color_fg;
|
||
|
|
} else {
|
||
|
|
_pixset[_pixstart + (_pixrange / 2) + 1 + i] = _color_fg;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
CRGB dim1 = CRGB(_color_fg.r * 0.2,_color_fg.g * 0.2, _color_fg.b * 0.2);
|
||
|
|
CRGB dim2 = CRGB(_color_fg.r * 0.1,_color_fg.g * 0.1, _color_fg.b * 0.1);
|
||
|
|
_pixset[_pixstart + _pixrange / 2] = dim1;
|
||
|
|
_pixset[_pixstart + _pixrange / 2 + 1] = dim2;
|
||
|
|
if (_pixrange % 2 == 0) {
|
||
|
|
_pixset[_pixstart + _pixrange / 2 - 1] = dim1;
|
||
|
|
_pixset[_pixstart + _pixrange / 2 - 2] = dim2;
|
||
|
|
} else {
|
||
|
|
_pixset[_pixstart + _pixrange / 2 - 1] = dim2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Effect NeoPixelEffects::getEffect()
|
||
|
|
{
|
||
|
|
return _effect;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setRange(int pixstart, int pixend)
|
||
|
|
{
|
||
|
|
if (pixstart >= 0 && pixstart <= pixend) {
|
||
|
|
_pixstart = pixstart;
|
||
|
|
_pixend = pixend;
|
||
|
|
_pixrange = _pixend - _pixstart + 1;
|
||
|
|
}
|
||
|
|
if (_direction == FORWARD) {
|
||
|
|
_pixcurrent = _pixstart;
|
||
|
|
} else {
|
||
|
|
_pixcurrent = _pixend;
|
||
|
|
}
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setAreaOfEffect(int aoe)
|
||
|
|
{
|
||
|
|
if (aoe > 0 && aoe <= _pixrange) {
|
||
|
|
_pixaoe = aoe;
|
||
|
|
}
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setDelayHz(int delay_hz)
|
||
|
|
{
|
||
|
|
if (delay_hz > 0) {
|
||
|
|
_delay = (unsigned long)(1.0 / delay_hz * 1000);
|
||
|
|
}
|
||
|
|
update();
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setDelay(unsigned long delay_ms)
|
||
|
|
{
|
||
|
|
_delay = delay_ms;
|
||
|
|
_lastupdate = 0;
|
||
|
|
update();
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setColor(CRGB color_crgb)
|
||
|
|
{
|
||
|
|
_color_fg = color_crgb;
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setBackgroundColor(CRGB color_crgb)
|
||
|
|
{
|
||
|
|
_color_bg = color_crgb;
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setStatus(EffectStatus status)
|
||
|
|
{
|
||
|
|
_status = status;
|
||
|
|
if (status == ACTIVE) {
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
EffectStatus NeoPixelEffects::getStatus()
|
||
|
|
{
|
||
|
|
return(_status);
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setRepeat(bool repeat)
|
||
|
|
{
|
||
|
|
_repeat = repeat;
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::setDirection(bool direction)
|
||
|
|
{
|
||
|
|
_direction = direction;
|
||
|
|
_lastupdate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::stop()
|
||
|
|
{
|
||
|
|
clear();
|
||
|
|
setEffect(NONE);
|
||
|
|
setStatus(INACTIVE);
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::pause()
|
||
|
|
{
|
||
|
|
if (getEffect() != NONE && getStatus() == ACTIVE) {
|
||
|
|
setStatus(INACTIVE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::play()
|
||
|
|
{
|
||
|
|
if (getEffect() != NONE && getStatus() != ACTIVE) {
|
||
|
|
setStatus(ACTIVE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::clear()
|
||
|
|
{
|
||
|
|
fill_solid(CRGB::Black);
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::fill_solid(CRGB color_crgb)
|
||
|
|
{
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
_pixset[i] = color_crgb;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NeoPixelEffects::fill_gradient(CRGB color_crgb1, CRGB color_crgb2)
|
||
|
|
{
|
||
|
|
int delta_red = color_crgb1.r - color_crgb2.r;
|
||
|
|
int delta_green = color_crgb1.g - color_crgb2.g;
|
||
|
|
int delta_blue = color_crgb1.b - color_crgb2.b;
|
||
|
|
|
||
|
|
for (int i = _pixstart; i <= _pixend; i++) {
|
||
|
|
float part = (float)(i - _pixstart) / _pixrange;
|
||
|
|
uint8_t grad_red = color_crgb1.r - (delta_red * part);
|
||
|
|
uint8_t grad_green = color_crgb1.g - (delta_green * part);
|
||
|
|
uint8_t grad_blue = color_crgb1.b - (delta_blue * part);
|
||
|
|
_pixset[i] = CRGB(grad_red, grad_green, grad_blue);
|
||
|
|
}
|
||
|
|
}
|