Your way to work with strings (e.g. PixelState) is wrong, but for a “boolean” state a string is the wrong type anyway.
As already stated in the original thread, you need to completely understand how that code works.
animHead and animTail are the variables that mark the position of multiple animations in the anim[] ring buffer for concurrent animations active on the strip.
As long there is a difference between the two markers, you have unfinished animations to execute.
Thanks @ScruffR
I've changed PixelState to a bool.
What do you mean by this statement?
As long there is a difference between the two markers, you have unfinished animations to execute.
animTail increments only when len is less than or equal to 0. Is this wrong?
I'm really trying to understand the code.
animHead starts at 0. When a comet gets added, animHead increments by 1. When it hits 100, it starts back at 0. animHead is used to index through anim array to store each new comet pattern.
animTail starts at 0. animTail increments by 1 when a comet finishes its run and exits the 5meter strip. When animTail hits 100, it starts back at 0.
animationStep starts at 0/animTail.
It's used to get each new comet pattern in the anim array.
However, I'm still unsure of how to add a new comet to the anim buffer ring to concurrently run with previously added comets. I'm not sure what the blocker is here.
/* ======================= includes ================================= */
#include "Particle.h"
#include <neopixel.h>
SYSTEM_MODE(AUTOMATIC);
#define PIXEL_COUNT 864
#define PIXEL_PIN D1
#define PIXEL_TYPE SK6812RGBW
Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
struct ANIMATION_DATA {
uint8_t g;
uint8_t r;
uint8_t b;
int pos;
int len;
};
// circular buffer with 100 slots will overwrite unfinished animations when full
const int maxAnim = 100;
int animHead = 0;
int animTail = 0;
ANIMATION_DATA anim[maxAnim];
const uint8_t whiteAnim[] = { 255, 200, 175, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t brightAnim[] = { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 245, 240, 240, 240, 240, 235, 230, 230, 230, 230, 225, 220, 220, 220, 220, 215, 210, 210, 210, 210, 205, 200, 200, 200, 200, 200, 195, 195, 190, 190, 190, 190, 190, 195, 180, 180, 180, 175, 170, 165, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70};
const int cometLen = sizeof(whiteAnim) / sizeof(whiteAnim[0]);
const uint32_t msRefresh = 0;
const int stepSpeed = 10;
static int animationStep = 0;
void setup() {
memset(anim, 0, sizeof(anim));
strip.begin();
strip.show(); // Initialize all pixels to 'off'
Particle.function("led", addComet);
//strip.setBrightness(30);
}
static bool PixelState = false;
static int Pixel;
void loop() {
static uint32_t msDelay = 0;
if (millis() - msDelay < msRefresh) return;
msDelay = millis();
if (PixelState == false) {
Pixel = random(PIXEL_COUNT);
strip.setPixelColor(Pixel,random(255), random(255), random(255), 100);
strip.show();
PixelState = true;
} else {
strip.setPixelColor(Pixel,0,0,0,0);
strip.show();
PixelState = false;
}
if (animHead != animTail) {
ANIMATION_DATA *a;
animationStep = animTail;
if (animationStep != animHead) {
/*Serial.println("animationStep");
Serial.println(animationStep);
Serial.println("i");
Serial.println(i);
Serial.println("animTail");
Serial.println(animTail);
Serial.println("animHead");
Serial.println(animHead);*/
a = &anim[animationStep];
if (a->len) {
int px;
//Draw the Comet
for (int p = a->len-1; p >= 0; p--) {
px = constrain(a->pos - p, 0, PIXEL_COUNT-1);
strip.setColorDimmed(px, a->g, a->r, a->b, whiteAnim[p], brightAnim[p]);
}
//Erase the pixels behind comet as it moves forward
if (a->pos - a->len >= 0) {
for (int k = 0; k < stepSpeed; k++) {
strip.setPixelColor(a->pos-k - a->len, 0);
}
}
//Make comet jump forward stepSpeed pixels at a time to make comet run seemingly faster
if (a->pos < PIXEL_COUNT+stepSpeed) {
a->pos+=stepSpeed;
}
else {
a->len-=stepSpeed;
}
if (a->len <= 0) {
*a = { 0, 0, 0, 0, 0};
animTail++;
animTail %= maxAnim;
}
}
animationStep++;
animationStep %= maxAnim;
}
strip.show();
}
}
int addComet(String command) {
int retVal = -1;
if (command=="login") {
anim[animHead] = { 200, 200, 200, 0, cometLen }; // white
retVal = 0;
Particle.publish("login");
}
else if (command=="idea") {
anim[animHead] = { 255, 255, 0, 0, cometLen }; // yellow
retVal = 1;
Particle.publish("idea");
}
else if (command=="comment") {
anim[animHead] = { 0, 0, 255, 0, cometLen }; // blue
retVal = 2;
Particle.publish("comment");
}
else if (command=="outcome") {
anim[animHead] = { 255, 0, 0, 0, cometLen }; // green
retVal = 3;
Particle.publish("outcome");
}
else if (command=="project") {
anim[animHead] = { 255, 0, 0, 0, cometLen }; // green
retVal = 4;
Particle.publish("project");
}
else if (command=="status") {
anim[animHead] = { 100, 255, 0, 0, cometLen }; // orange
retVal = 5;
Particle.publish("status");
}
else if (command=="step") {
anim[animHead] = { 0, 75, 255, 0, cometLen }; // purple
retVal = 6;
Particle.publish("step");
}
else if (command=="vote") {
anim[animHead] = { 0, 255, 0, 0, cometLen }; // red
retVal = 7;
Particle.publish("vote");
}
else if (command=="view") {
anim[animHead] = { 105, 255, 200, 0, cometLen }; // pink
retVal = 7;
Particle.publish("view");
}
animHead++;
animHead %= maxAnim;
return retVal;
}
@Moors7 Do you have any comments on this?
What do you mean by this comment:
// but still scope the block
Do you mean replace that for loop with an if statement?
For example...
animationStep = animTail;
if (animationStep != animHead) {
...
animationStep++;
animationStep %= maxAnim;
}
Not quite.
By removing the for() line, you remove the loop, but by leaving the curly braces of the (previous to be) for() block, the contents of this block will still have its own scope - meaning: Variables declared inside that code block will not be visible/accessible outside the { ... } block.
Oh, interesting. Okay, thank you.
Hi @ScruffR
Did you see my edits in my last post? I’m feeling lost in how to make my comets run concurrently, instead of waiting for each previous comet to finish before the next comet enters the strip. Removing the if statements doesn’t make any change.
I’ve tried moving the placement of the animationStep++ earlier, but it still doesn’t increment until the previous comet has finished its run.
First I’d like to propose a different approach for your addCommet() function - I don’t really like seeing copy/past code blocks like there 
Try this instad
struct topic {
char title[16];
uint8_t rgb[3];
};
const topic topicList[] =
{ { "login" , { 200, 200, 200 } }
, { "idea" , { 255, 255, 0 } }
, { "comment", { 0, 0, 255 } }
, { "outcome", { 255, 0, 0 } }
, { "project", { 255, 0, 0 } }
, { "status" , { 255, 0, 0 } }
, { "step" , { 0, 75, 255 } }
, { "vote" , { 0, 255, 0 } }
, { "view" , { 105, 255, 200 } }
};
const int topics = sizeof(topicList)/sizeof(topicList[0]);
int addComet(String command)
{
int retVal = -1;
for (int i = 0; i < topics; i++)
{
if (strcmp((const char*)command, topicList[i].title) == 0)
{
anim[animHead] = { topicList[i].rgb[0], topicList[i].rgb[1], topicList[i].rgb[2], 0, cometLen }; // purple
animHead++;
animHead %= maxAnim;
Particle.publish(command);
retVal = i;
break;
}
}
return retVal;
}
About the concurrent animations I’m not sure why you see them sequential. The code is meant to allow for concurrency, but I have no means to test the actual action due to the lack of 864 NeoPixels
The trouble occurred when I was trying to add the twinkling lights in the background.
This comets work perfectly in this code without the background twinkling lights:
// This #include statement was automatically added by the Particle IDE.
#include <neopixel.h>
/* ======================= includes ================================= */
#include "Particle.h"
SYSTEM_MODE(AUTOMATIC);
#define PIXEL_COUNT 864
#define PIXEL_PIN D1
#define PIXEL_TYPE SK6812RGBW
Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
struct ANIMATION_DATA {
uint8_t g;
uint8_t r;
uint8_t b;
int pos;
int len;
};
// circular buffer with 100 slots will overwrite unfinished animations when full
const int maxAnim = 100;
int animHead = 0;
int animTail = 0;
ANIMATION_DATA anim[maxAnim];
const uint8_t cometAnim[] = { 255, 200, 175, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t brightAnim[] = { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 245, 240, 240, 240, 240, 235, 230, 230, 230, 230, 225, 220, 220, 220, 220, 215, 210, 210, 210, 210, 205, 200, 200, 200, 200, 200, 195, 195, 190, 190, 190, 190, 190, 195, 180, 180, 180, 175, 170, 165, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70};
const int cometLen = sizeof(cometAnim) / sizeof(cometAnim[0]);
const uint32_t msRefresh = 0;
const int stepSpeed = 10;
void setup() {
memset(anim, 0, sizeof(anim));
strip.begin();
strip.show(); // Initialize all pixels to 'off'
Particle.function("led", addComet);
}
void loop() {
static uint32_t msDelay = 0;
if (millis() - msDelay < msRefresh) return;
msDelay = millis();
if (animHead != animTail) {
ANIMATION_DATA *a;
for (int i = animTail; i != animHead; ) {
a = &anim[i];
if (a->len) {
int px;
//Draw the Comet
for (int p = a->len-1; p >= 0; p--) {
px = constrain(a->pos - p, 0, strip.numPixels()-1);
strip.setColorDimmed(px, a->g, a->r, a->b, cometAnim[p], brightAnim[p]);
}
//Erase the pixels behind comet as it moves forward
if (a->pos - a->len >= 0) {
for (int k = 0; k < stepSpeed; k++) {
strip.setPixelColor(a->pos-k - a->len, 0);
}
}
//Make comet jump forward stepSpeed pixels at a time to make comet run seemingly faster
if (a->pos < PIXEL_COUNT) {
a->pos+=stepSpeed;
}
else {
a->len-=stepSpeed;
}
if (a->len <= 0) {
*a = { 0, 0, 0, 0, 0};
animTail++;
animTail %= maxAnim;
}
}
i++;
i %= maxAnim;
}
strip.show();
}
}
int addComet(String command) {
int retVal = -1;
if (command=="login") {
anim[animHead] = { 200, 200, 200, 0, cometLen }; // white
retVal = 0;
Particle.publish("login");
}
else if (command=="idea") {
anim[animHead] = { 255, 255, 0, 0, cometLen }; // yellow
retVal = 1;
Particle.publish("idea");
}
else if (command=="comment") {
anim[animHead] = { 0, 0, 255, 0, cometLen }; // blue
retVal = 2;
Particle.publish("comment");
}
else if (command=="outcome") {
anim[animHead] = { 255, 0, 0, 0, cometLen }; // green
retVal = 3;
Particle.publish("outcome");
}
else if (command=="project") {
anim[animHead] = { 255, 0, 0, 0, cometLen }; // green
retVal = 4;
Particle.publish("project");
}
else if (command=="status") {
anim[animHead] = { 100, 255, 0, 0, cometLen }; // orange
retVal = 5;
Particle.publish("status");
}
else if (command=="step") {
anim[animHead] = { 0, 75, 255, 0, cometLen }; // purple
retVal = 6;
Particle.publish("step");
}
else if (command=="vote") {
anim[animHead] = { 0, 255, 0, 0, cometLen }; // red
retVal = 7;
Particle.publish("vote");
}
else if (command=="view") {
anim[animHead] = { 105, 255, 200, 0, cometLen }; // pink
retVal = 7;
Particle.publish("view");
}
animHead++;
animHead %= maxAnim;
return retVal;
}
However, when I tried to add in the twinkling lights in the background, the comets stopped running concurrently. Can you see where I went wrong when I tried to implement the twinkling lights?
/* ======================= includes ================================= */
#include "Particle.h"
#include <neopixel.h>
SYSTEM_MODE(AUTOMATIC);
#define PIXEL_COUNT 864
#define PIXEL_PIN D1
#define PIXEL_TYPE SK6812RGBW
Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
struct ANIMATION_DATA {
uint8_t g;
uint8_t r;
uint8_t b;
int pos;
int len;
};
// circular buffer with 100 slots will overwrite unfinished animations when full
const int maxAnim = 100;
int animHead = 0;
int animTail = 0;
ANIMATION_DATA anim[maxAnim];
const uint8_t whiteAnim[] = { 255, 200, 175, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t brightAnim[] = { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 245, 240, 240, 240, 240, 235, 230, 230, 230, 230, 225, 220, 220, 220, 220, 215, 210, 210, 210, 210, 205, 200, 200, 200, 200, 200, 195, 195, 190, 190, 190, 190, 190, 195, 180, 180, 180, 175, 170, 165, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70};
const int cometLen = sizeof(whiteAnim) / sizeof(whiteAnim[0]);
const uint32_t msRefresh = 0;
const int stepSpeed = 10;
static int animationStep = 0;
static bool PixelState = false;
static int Pixel;
void setup() {
memset(anim, 0, sizeof(anim));
strip.begin();
strip.show(); // Initialize all pixels to 'off'
Particle.function("led", addComet);
//strip.setBrightness(30);
Serial.begin(9600);
}
void loop() {
static uint32_t msDelay = 0;
if (millis() - msDelay < msRefresh) return;
msDelay = millis();
if (PixelState == false) {
Pixel = random(PIXEL_COUNT);
strip.setPixelColor(Pixel,random(255), random(255), random(255), 100);
strip.show();
PixelState = true;
} else {
strip.setPixelColor(Pixel,0,0,0,0);
strip.show();
PixelState = false;
}
//if (animHead != animTail)
{
ANIMATION_DATA *a;
animationStep = animTail;
{
/*Serial.println("animationStep");
Serial.println(animationStep);
Serial.println("animTail");
Serial.println(animTail);
Serial.println("animHead");
Serial.println(animHead);*/
a = &anim[animationStep];
Serial.println("animationStep");
Serial.println(animationStep);
//if (a->len)
{
int px;
//Draw the Comet
for (int p = a->len-1; p >= 0; p--) {
px = constrain(a->pos - p, 0, PIXEL_COUNT-1);
strip.setColorDimmed(px, a->g, a->r, a->b, whiteAnim[p], brightAnim[p]);
}
//Erase the pixels behind comet as it moves forward
if (a->pos - a->len >= 0) {
for (int k = 0; k < stepSpeed; k++) {
strip.setPixelColor(a->pos-k - a->len, 0);
}
}
//Make comet jump forward stepSpeed pixels at a time to make comet run seemingly faster
if (a->pos < PIXEL_COUNT+stepSpeed) {
a->pos+=stepSpeed;
}
else {
a->len-=stepSpeed;
}
if (a->len <= 0) {
*a = { 0, 0, 0, 0, 0};
animTail++;
animTail %= maxAnim;
}
}
animationStep++;
animationStep %= maxAnim;
}
strip.show();
}
}
int addComet(String command) {
int retVal = -1;
if (command=="login") {
anim[animHead] = { 200, 200, 200, 0, cometLen }; // white
retVal = 0;
Particle.publish("login");
}
else if (command=="idea") {
anim[animHead] = { 255, 255, 0, 0, cometLen }; // yellow
retVal = 1;
Particle.publish("idea");
}
else if (command=="comment") {
anim[animHead] = { 0, 0, 255, 0, cometLen }; // blue
retVal = 2;
Particle.publish("comment");
}
else if (command=="outcome") {
anim[animHead] = { 255, 0, 0, 0, cometLen }; // green
retVal = 3;
Particle.publish("outcome");
}
else if (command=="project") {
anim[animHead] = { 255, 0, 0, 0, cometLen }; // green
retVal = 4;
Particle.publish("project");
}
else if (command=="status") {
anim[animHead] = { 100, 255, 0, 0, cometLen }; // orange
retVal = 5;
Particle.publish("status");
}
else if (command=="step") {
anim[animHead] = { 0, 75, 255, 0, cometLen }; // purple
retVal = 6;
Particle.publish("step");
}
else if (command=="vote") {
anim[animHead] = { 0, 255, 0, 0, cometLen }; // red
retVal = 7;
Particle.publish("vote");
}
else if (command=="view") {
anim[animHead] = { 105, 255, 200, 0, cometLen }; // pink
retVal = 7;
Particle.publish("view");
}
animHead++;
animHead %= maxAnim;
return retVal;
}One of the problems - as already mentioned in this thread - is that you are calling strip.show() more than once per loop() iteration.
strip.show() is the most time consuming function in your whole project.
The logic of my original code is to setup all the LEDs according to all concurrent animations in the pixel buffer only and only after all pixels have been set to the correct combination of values call strip.show() once and only once per visit to loop().
The other thing why you are not seeing the concurrent animations is that we got rid of the for() loop that took care of multiple animations - for testing purposes only tho'
Have a try with this then
#include <Particle.h>
#include <neopixel.h>
SYSTEM_MODE(AUTOMATIC)
const int PIXEL_COUNT = 864;
const int PIXEL_PIN = D1;
const int PIXEL_TYPE = SK6812RGBW;
Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
struct ANIMATION_DATA
{
uint8_t g;
uint8_t r;
uint8_t b;
int pos;
int len;
};
// circular buffer with 100 slots will overwrite unfinished animations when full
const int maxAnim = 100;
int animHead = 0;
int animTail = 0;
ANIMATION_DATA anim[maxAnim];
const uint8_t whiteAnim[] =
{ 255, 200, 175, 160, 155, 150, 145, 140, 135, 130
, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80
, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30
, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0
};
const uint8_t brightAnim[] =
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
, 255, 255, 255, 255, 255, 255, 255, 255, 245, 240
, 240, 240, 240, 235, 230, 230, 230, 230, 225, 220
, 220, 220, 220, 215, 210, 210, 210, 210, 205, 200
, 200, 200, 200, 200, 195, 195, 190, 190, 190, 190
, 190, 195, 180, 180, 180, 175, 170, 165, 160, 155
, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105
, 100, 95, 90, 85, 80, 75, 70
};
const int cometLen = sizeof(whiteAnim) / sizeof(whiteAnim[0]);
const uint32_t msRefresh = 0;
const int stepSpeed = 10;
static int animationStep = 0;
void setup()
{
memset(anim, 0, sizeof(anim));
strip.begin();
strip.show(); // Initialize all pixels to 'off'
Particle.function("led", addComet);
//strip.setBrightness(30);
}
void loop()
{
static uint32_t msDelay = 0;
if (millis() - msDelay < msRefresh) return;
msDelay = millis();
static bool sparkleState = false;
static int sparklePixel = 0;
if (animHead != animTail)
{
ANIMATION_DATA *a;
for (int animationStep = animTail; animationStep != animHead; )
{
a = &anim[animationStep];
if (a->len)
{
int px;
//Draw the Comet
for (int p = a->len - 1; p >= 0; p--)
{
px = constrain(a->pos - p, 0, PIXEL_COUNT - 1);
strip.setColorDimmed(px, a->g, a->r, a->b, whiteAnim[p], brightAnim[p]);
}
//Erase the pixels behind comet as it moves forward
if (a->pos - a->len >= 0)
for (int k = 0; k < stepSpeed; k++)
strip.setPixelColor(a->pos - k - a->len, 0);
//Make comet jump forward stepSpeed pixels at a time to make comet run seemingly faster
if (a->pos < PIXEL_COUNT + stepSpeed)
a->pos += stepSpeed;
else
a->len -= stepSpeed;
if (a->len <= 0)
{
*a = { 0, 0, 0, 0, 0 };
animTail++;
animTail %= maxAnim;
}
}
animationStep++;
animationStep %= maxAnim;
}
}
sparkleState = !sparkleState; // flip state
if (sparkleState)
{
sparklePixel = random(PIXEL_COUNT);
strip.setPixelColor(sparklePixel, random(255), random(255), random(255), 100);
}
else
strip.setPixelColor(sparklePixel, 0, 0, 0, 0);
strip.show();
}
struct topic {
char title[16];
uint8_t rgb[3];
};
const topic topicList[] =
{ { "login" , { 200, 200, 200 } }
, { "idea" , { 255, 255, 0 } }
, { "comment", { 0, 0, 255 } }
, { "outcome", { 255, 0, 0 } }
, { "project", { 255, 0, 0 } }
, { "status" , { 255, 0, 0 } }
, { "step" , { 0, 75, 255 } }
, { "vote" , { 0, 255, 0 } }
, { "view" , { 105, 255, 200 } }
};
const int topics = sizeof(topicList)/sizeof(topicList[0]);
int addComet(String command)
{
int retVal = -1;
for (int i = 0; i < topics; i++)
{
if (strcmp((const char*)command, topicList[i].title) == 0)
{
anim[animHead] = { topicList[i].rgb[0], topicList[i].rgb[1], topicList[i].rgb[2], 0, cometLen }; // purple
Particle.publish(command);
animHead++;
animHead %= maxAnim;
retVal = i;
break;
}
}
return retVal;
}
When there’s a lot of activity in the software and the endpoints are getting hit at a high frequency, the light strips start to flash in odd patterns. Maybe there’s no solution for this, but do you know why this happens? Is it because of faulty wiring or the photon just can’t handle that much activity at once?
It only happens when a ton of comets are trying to run.
Neopixels can use up to 60mA per LED, so how big is your power supply?
I’m using a 5V 10A power supply. By ‘odd pattern’ I don’t just mean dimming, though. It actually starts to flash when there’s no flashing that should be happening.