So, ich habe mal was versucht.
Es wird vermutlich nicht auf Anhieb funktionieren, aber irgendwo muss ja start sein.
Das folgende Codestück soll nur eine Animation zeigen, die gänzlich ohne delay() auskommt.
Bitte beachte, das ich weder einen MEGA noch einen Nextion, noch einen Stripe habe um irgendwas auszuprobieren. Das ist alles aus dem Bauch heraus gemacht um die grauen Zellen ein wenig anzustrengen....
Was der Code machen soll:
Es soll mit dem Start auf jedem Becher ein roter Punkt durchlaufen, dann ein grüner, dann soll der Becher grün sein.
Es soll zu jedem Team eine Message an den Nextion gesendet werden, in dem die 10 Becher als counter ausgegeben werden. - Wenn das nicht funktioniert kein Problem, das ist erstmal Nebensache.
Wichtiger ist, das Du vom Nextion etwas senden sollst und das ohne die Animation zu stören, auf dem SerMon ausgegeben werden soll.
Ich habe in animateCupWithClear() kommentiert, was dort passieren soll. Die Funktion darunter ist genauso, nur ohne das die Pixel gelöscht werden und alle anderen erklären sich eigentlich selbst.
Mach was draus. - Wenn Du Team2 nicht angeschlossen hast, kein Problem, siehst Du nur für die Zeit nix. Das Ding fängt ja immer wieder bei Team 1 an 
Ohne Garantie auf irgendwas - aber ein Versuch ist es wert.
Kompiliert Fehler- und Warnungsfrei.
#define nextion Serial2 //Seriele Schnittstelle 2 für Nextion
String daten_display = ""; //Serieler Speicher
//unsigned long initDelayLenght = 0;
//int initDelayLong = 100;
//-----------------------------PINs und Zustände-------------------------------------------------//
bool Einzelspiel;
bool Tunier;
//bool TischAN = false;
const byte Laser = 9;
const byte teamNums = 2; // Anzahl spielende Mannschaften
const byte becherNums = 10; // Anzahl Becher je Mannschaft
enum {steht, getroffen, umgefallen};
byte treffer[teamNums][becherNums] = {0}; // Merker nicht getroffene Becher entspricht 0,
const byte becherLaser[teamNums][becherNums] = // Für jedes Team Eingänge für Treffererkennung
{
{22, 23, 24, 25, 26, 27, 28, 29, 30, 31,},
{32, 33, 34, 35, 36, 37, 38, 39, 40, 41,},
};
const byte ledPin[teamNums][becherNums] = // Jedes Team Ausgang je Becher
{
{42, 43, 44, 45, 46, 47, 48, 49, 50, 51},
{ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13},
};
uint32_t lastLedAction[teamNums][becherNums] = {0}; // Merker für Animationszeiten
byte lastLedAnimatet[teamNums][becherNums] = {0}; // Merker für die letzte animierte lED
bool doubleHit[teamNums] = {false};
//-----------------------------------------------NEO PIXEL Team 1--------------------------------------------------------------//
#include <Adafruit_NeoPixel.h>
//uint8_t HelligkeitbecherLED = 100; //Helligkeit aller LED [geregelt über Nextion]
const uint8_t becherLED = 15; //Anzahl LED pro Becher
Adafruit_NeoPixel becherLicht[teamNums][becherNums] =
{
{
Adafruit_NeoPixel(becherLED, ledPin[0][0], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][1], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][2], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][3], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][4], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][5], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][6], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][7], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][8], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[0][9], NEO_GRB + NEO_KHZ800),
},
{
Adafruit_NeoPixel(becherLED, ledPin[1][0], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][1], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][2], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][3], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][4], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][5], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][6], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][7], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][8], NEO_GRB + NEO_KHZ800),
Adafruit_NeoPixel(becherLED, ledPin[1][9], NEO_GRB + NEO_KHZ800),
},
};
const uint32_t aqua = 8388567; // Die Zahl ergibt sich aus dem Farbcode 16 << r | 8 << g | b
const uint32_t blau = 4286945;
const uint32_t drot = 13434880;
const uint32_t gruen = 8190976;
const uint32_t lila = 10105548;
const uint32_t magenta = 16711935;
const uint32_t orange = 16728064;
const uint32_t rot = 16724016;
enum {start, readLaser,}; // Einzelne Zustände...
byte zustand = start;
//
//----------------------------------------------Timer----------------------------------------------------//
//int myTimeOut = 30000; //Zeit in ms (Zeit für Doppeltetrefferkennung)
//__________________________________________________________________________________________________________________________________________________________________________________________//
void setup()
{
nextion.begin(9600); // Display Schnittstelle
Serial.begin(9600); // DEBUG Schnittstelle
Serial.println(F("Start..."));
for (byte t = 0; t < teamNums; t++)
{
for (byte b = 0; b < becherNums; b++)
{
becherLicht[t][b].begin();
}
}
clearAllCup();
}
//
void loop()
{
readHMI();
switch (zustand)
{
case start:
if (startAnimation() == false) // Wenn Startanimation nicht mehr aktiv
{ zustand = readLaser; } // nächsten Step
break;
case readLaser:
Serial.println(F("Hier ist Schluss!"));
Serial.println(F("Fange an von Vorn"));
zustand = start;
break;
}
}
//
void readHMI()
{
if (nextion.available() > 0)
{
Serial.print(nextion.read()); // Eingelesenes wieder ausgeben
}
}
//
//
bool startAnimation()
{
enum {init, dotRed, dotGreen, fullGreen};
static byte zustand = init;
static byte t = 0, b = 0;
char buf[20] = {'\0'};
bool returnWert = true;
switch (zustand)
{
case init:
for (; t < teamNums; t++) // durchlaufe alle Teams
{
for (; b < becherNums; b++) // durchlaufe alle Becher
{
treffer[t][b] = false; // setze Merker
lastLedAnimatet[t][b] = 0; // startLED vorbereiten
}
snprintf(buf, sizeof(buf) - 1, "n1%d.val=%d", t, teamCount(t)); // zusammensetzen zu übertragene Daten für team
nextion.print(buf); // Daten übertargen
nextionEnd(); // Übertragung ende
memset(buf, '\0', sizeof(buf)); // buffer leeren
} // Ende Team
t = 0; // Variablen zurücksetzen
b = 0;
clearAllCup(); //
zustand = dotRed; // nächster Schritt
break;
case dotRed:
if (t < teamNums) // Prüfung auf Team vorhanden
{
if (b < becherNums) // Becher vorhanden
{
if (animateCupWithClear(t, b, drot)) // Animation erledigt?
{ b++; } // nächsten Becher setzen
}
else // Becher nicht vorhanden (Überlauf)
{
b = 0; // setze Becher zurück
t++; // nächstes Team
}
}
else // Team nicht vorhenden (Überlauf)
{
b = 0; // setze alles zurück
t = 0;
clearAllCup(); // lösche Animation
zustand = dotGreen; // nächster Schritt
}
break;
case dotGreen:
if (t < teamNums) // Siehe vorher
{
if (b < becherNums)
{
if (animateCupWithClear(t, b, gruen)) // Wenn Animation erledigt
{
b++; // Alles andere wie vorher
}
}
else
{
b = 0;
t++;
}
}
else // alle Becher und teams durch
{
b = 0;
t = 0;
clearAllCup();
zustand = fullGreen;
}
break;
case fullGreen:
for (; t < teamNums; t++) // Schleife für Teams
{
for (; b < becherNums; b++) // Schleife für Becher
{ fillCup(t, b, gruen); } // Funktionsaufruf
}
b = 0;
t = 0;
analogWrite (Laser, 150);
zustand = init;
returnWert = false; // setzen das startSequenz nicht mehr aktiv
break;
}
return returnWert;
}
//
void clearAllCup()
{
for (byte t = 0; t < teamNums; t++)
{
for (byte b = 0; b < becherNums; b++)
{
becherLicht[t][b].clear();
becherLicht[t][b].show();
lastLedAnimatet[t][b] = 0;
}
}
}
//
void fillCup(const byte team, const byte cup, const uint32_t color)
{
becherLicht[team][cup].fill(color, 0, becherLED - 1);
becherLicht[team][cup].show();
}
//
bool animateCupWithClear(const byte team, const byte cup, const uint32_t color)
{
const uint32_t intervall = 150; // Pausezeit
bool fertig = false; //
if (millis() - lastLedAction[team][cup] > intervall || // Zeit abgelaufen ODER
lastLedAnimatet[team][cup] == 0) // Erste LED am Becher
{
lastLedAction[team][cup] = millis(); // Ausführungszeit merken
becherLicht[team][cup].clear(); // Stripe löschen
becherLicht[team][cup].setPixelColor(lastLedAnimatet[team][cup], color); // Pixel setzen
becherLicht[team][cup].show(); // ausgeben
lastLedAnimatet[team][cup]++; // nächsten Pixel vormerken
}
if (lastLedAnimatet[team][cup] >= becherLED) // gesamter Stripe durch?
{
lastLedAnimatet[team][cup] = 0; // Wieder auf Anfang setzen
fertig = true; // Rückgabe Meldung setzen
}
return fertig; //
}
//
bool animateCup(const byte team, const byte cup, const uint32_t color)
{
const uint32_t intervall = 250;
bool fertig = false; //
if (millis() - lastLedAction[team][cup] > intervall ||
lastLedAnimatet[team][cup] == 0)
{
lastLedAction[team][cup] = millis();
if (lastLedAnimatet[team][cup] < becherLED)
{
becherLicht[team][cup].setPixelColor(lastLedAnimatet[team][cup], color);
becherLicht[team][cup].show();
lastLedAnimatet[team][cup]++;
}
else
{
lastLedAnimatet[team][cup] = 0;
fertig = true;
}
}
return fertig;
}
//
uint8_t teamCount(const uint8_t team)
{
uint8_t count = 0;
for (byte b = 0; b < becherNums; b++)
{
if (treffer[team][b] == false)
{ count++; }
}
return count;
}
//
void nextionEnd()
{
for (byte b = 0; b < 3; b++)
{
nextion.write (0xff);
}
}
//