PC Beleuchtung per WS2812B und Arduino

flippo710 · April 5, 2022, 12:56pm

Hallo liebe Freunde,
ich habe gestern meine neue Wasserkühlung für meinen Rechner bekommen und habe in dem Zuge direkt mein Gehäuse etwas aufgeräumt. Ich möchte nun außerdem im Gehäuse die Beleuchtung des Gehäuses erneuern von standard RGB Stripes auf die WS2812B. Ich habe die hier noch rumfliegen und ein Arduino Mega 2560 PRO liegt hier auch noch rum. Also die Dinger geschnappt und mir überlegt, dass beim Start des Rechners ein Python-Skript gestartet werden soll, welches über den internen USB des Motherboards den Arduino steuern soll bzw. der soll den Strip steuern.

Habe schon einige Projekte mit Arduino bzw. Strips gemacht und daher im ersten Moment an NeoPixel und PySerial gedacht. Nur irgendwie stehe ich ein wenig auf dem Schlauch und auch mittlerweile mehrere Stunden Googlen bringt mich nicht weiter.

Ich habe schon ohne Probleme den Arduino über meinen PC per Python angesprochen, also sprich, Verbindung etabliert und die interne LED blinken lassen. Soweit, so einfach.

Auf den Arduino Neopixel draufzuschmeißen ist jetzt auch keine große Sache, habe ich auch schonmal für meine NanoLeafs gemacht und eine Datenbank für Effekte gibt es ja hier:

Allerdings komme ich ehrlicherweise nicht wirklich mit der Art der Kommunikation zurecht. Geschrieben wird ja per serial.write() Funktion. Bedeutet das also, dass ich die Effekte auf dem Arduino schreibe, dann auf einen Input per .write() vom Rechner warte und diesen Input abfange und daraufhin den Effekt starte? Sprich, grob im Aufbau:

Wenn Input per write() == 1
starte Effekt 1

Wenn Input per write() == 2
starte Effekt 2

Wenn Input per write()( == "Stopp"
Starte Eingabe neu

Irgendwie stehe ich gerade auf dem Schlauch....

Danke euch im Voraus und sollte eine Info fehlen, gerne melden

LG
Philipp

HotSystems · April 5, 2022, 1:01pm

sieh dir einfach mal die Beispiel zur Library in NeoPixel oder Fastled an. Da siehst du, dass es nicht mit serial.write() funktioniert.

flippo710 · April 5, 2022, 1:13pm

Hallo,

ja, das ist mir klar, ich übergebe doch nur einen Wert an meinen Arudino mit serial.write(), diese Eingabe am Arudino verarbeite ich dann um einen Effekt in Neopixel (der Effekt ist ja simpel eine Funktion) zu starten.

HotSystems · April 5, 2022, 1:22pm

Dann solltest du das in deiner Beschreibung auch deutlicher schreiben.

Wie du mit der seriellen Schnittstelle umgehen kannst, findest du in den Beispielen der IDE. Da ist es die serielle Kommunikation und dann seriel.read().
Du willst ja mit dem Arduino etwas lesen, was du an der Tastatur eingibst.

my_xy_projekt · April 5, 2022, 1:37pm

Schickst Du nur ein Zeichen, oder kommt da nochwas (Steuerzeichen, weiteres Zeichen) hinterher?
Ich hab mal gebaut - Es wird nur ein Zeichen ausgewertet.
Schickst Du mehrere, also ein Wort, bleibt das letzte Zeichen (welches in der Liste ist) auswählbar ist als Auswahl stehen.

char auswahl;
char lastAuswahl;
void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
}

void loop()
{
  abfrage();
  ausgabe();
}

void abfrage()
{
  if (Serial.available() > 0)
  {
    char c = Serial.read();
    if (isAlphaNumeric(c))
      auswahl = c;
  }
}

void ausgabe()
{
  if (lastAuswahl == auswahl) return; // verhindert das ständige Neuschreiben
  lastAuswahl = auswahl;              // Merken, was der letzte Wert war
  Serial.print(F("Auswahl: "));
  switch (auswahl)                    // Je nach Auswahl aufrufen
  {
    case 'A':
      Serial.println('A');
      break;
    case 'b':
      Serial.println('b');
      break;
    case 'Z':
      Serial.println('Z');
      break;
    case '1':
      Serial.println('1');
      break;
  }
}

agmue · April 5, 2022, 2:01pm

Mir scheint der Link Arduino – All LEDStrip effects in one (NeoPixel and FastLED) für Dich besser geeignet, weil er mehrere Effekte zur Auswahl im Programm berücksichtigt.

Ich würde FastLED bevorzugen, daher schaue ich da mal in das Programm. Für mich sieht da switch(selectedEffect) vielversprechend aus. Alles bezüglich EEPROM und Taster muß raus und durch Serial.read() ersetzt werden, wo Du direkt eine Zahl 0 bis 18 oder ein Äquvalent wie Buchstaben 'a' bis 's'¹⁾ übergibst.

Getestet mit WS2815, Mega2560 und seriellem Monitor:

#include "FastLED.h"
#define NUM_LEDS 60
CRGB leds[NUM_LEDS];
#define PIN 5

byte selectedEffect = 0;

void setup()
{
  Serial.begin(9600);
  Serial.println(F("\nStart"));
  FastLED.addLeds<WS2811, PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
}

void serialEvent()
{
  char c = Serial.read();
    if (c >= 'a' && c <= 's') {
      selectedEffect = c - 'a';
      Serial.print(c);
      Serial.print('\t');
      Serial.println(selectedEffect);
    }
}

void loop() {
  switch (selectedEffect) {

    case 0  : {
        // RGBLoop - no parameters
        RGBLoop();
        break;
      }

    case 1  : {
        // FadeInOut - Color (red, green. blue)
        FadeInOut(0xff, 0x00, 0x00); // red
        FadeInOut(0xff, 0xff, 0xff); // white
        FadeInOut(0x00, 0x00, 0xff); // blue
        break;
      }

    case 2  : {
        // Strobe - Color (red, green, blue), number of flashes, flash speed, end pause
        Strobe(0xff, 0xff, 0xff, 10, 50, 1000);
        break;
      }

    case 3  : {
        // HalloweenEyes - Color (red, green, blue), Size of eye, space between eyes, fade (true/false), steps, fade delay, end pause
        HalloweenEyes(0xff, 0x00, 0x00,
                      1, 4,
                      true, random(5, 50), random(50, 150),
                      random(1000, 10000));
        HalloweenEyes(0xff, 0x00, 0x00,
                      1, 4,
                      true, random(5, 50), random(50, 150),
                      random(1000, 10000));
        break;
      }

    case 4  : {
        // CylonBounce - Color (red, green, blue), eye size, speed delay, end pause
        CylonBounce(0xff, 0x00, 0x00, 4, 10, 50);
        break;
      }

    case 5  : {
        // NewKITT - Color (red, green, blue), eye size, speed delay, end pause
        NewKITT(0xff, 0x00, 0x00, 8, 10, 50);
        break;
      }

    case 6  : {
        // Twinkle - Color (red, green, blue), count, speed delay, only one twinkle (true/false)
        Twinkle(0xff, 0x00, 0x00, 10, 100, false);
        break;
      }

    case 7  : {
        // TwinkleRandom - twinkle count, speed delay, only one (true/false)
        TwinkleRandom(20, 100, false);
        break;
      }

    case 8  : {
        // Sparkle - Color (red, green, blue), speed delay
        Sparkle(0xff, 0xff, 0xff, 0);
        break;
      }

    case 9  : {
        // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay
        SnowSparkle(0x10, 0x10, 0x10, 20, random(100, 1000));
        break;
      }

    case 10 : {
        // Running Lights - Color (red, green, blue), wave dealy
        RunningLights(0xff, 0x00, 0x00, 50); // red
        RunningLights(0xff, 0xff, 0xff, 50); // white
        RunningLights(0x00, 0x00, 0xff, 50); // blue
        break;
      }

    case 11 : {
        // colorWipe - Color (red, green, blue), speed delay
        colorWipe(0x00, 0xff, 0x00, 50);
        colorWipe(0x00, 0x00, 0x00, 50);
        break;
      }

    case 12 : {
        // rainbowCycle - speed delay
        rainbowCycle(20);
        break;
      }

    case 13 : {
        // theatherChase - Color (red, green, blue), speed delay
        theaterChase(0xff, 0, 0, 50);
        break;
      }

    case 14 : {
        // theaterChaseRainbow - Speed delay
        theaterChaseRainbow(50);
        break;
      }

    case 15 : {
        // Fire - Cooling rate, Sparking rate, speed delay
        Fire(55, 120, 15);
        break;
      }


    // simple bouncingBalls not included, since BouncingColoredBalls can perform this as well as shown below
    // BouncingColoredBalls - Number of balls, color (red, green, blue) array, continuous
    // CAUTION: If set to continuous then this effect will never stop!!!

    case 16 : {
        // mimic BouncingBalls
        byte onecolor[1][3] = { {0xff, 0x00, 0x00} };
        BouncingColoredBalls(1, onecolor, false);
        break;
      }

    case 17 : {
        // multiple colored balls
        byte colors[3][3] = { {0xff, 0x00, 0x00},
          {0xff, 0xff, 0xff},
          {0x00, 0x00, 0xff}
        };
        BouncingColoredBalls(3, colors, false);
        break;
      }

    case 18 : {
        // meteorRain - Color (red, green, blue), meteor size, trail decay, random trail decay (true/false), speed delay
        meteorRain(0xff, 0xff, 0xff, 10, 64, true, 30);
        break;
      }
  }
}

// *************************
// ** LEDEffect Functions **
// *************************

void RGBLoop() {
  for (int j = 0; j < 3; j++ ) {
    // Fade IN
    for (int k = 0; k < 256; k++) {
      switch (j) {
        case 0: setAll(k, 0, 0); break;
        case 1: setAll(0, k, 0); break;
        case 2: setAll(0, 0, k); break;
      }
      showStrip();
      delay(3);
    }
    // Fade OUT
    for (int k = 255; k >= 0; k--) {
      switch (j) {
        case 0: setAll(k, 0, 0); break;
        case 1: setAll(0, k, 0); break;
        case 2: setAll(0, 0, k); break;
      }
      showStrip();
      delay(3);
    }
  }
}

void FadeInOut(byte red, byte green, byte blue) {
  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;
    setAll(r, g, b);
    showStrip();
  }

  for (int k = 255; k >= 0; k = k - 2) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }
}

void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause) {
  for (int j = 0; j < StrobeCount; j++) {
    setAll(red, green, blue);
    showStrip();
    delay(FlashDelay);
    setAll(0, 0, 0);
    showStrip();
    delay(FlashDelay);
  }

  delay(EndPause);
}

void HalloweenEyes(byte red, byte green, byte blue,
                   int EyeWidth, int EyeSpace,
                   boolean Fade, int Steps, int FadeDelay,
                   int EndPause) {
  randomSeed(analogRead(0));

  int i;
  int StartPoint  = random( 0, NUM_LEDS - (2 * EyeWidth) - EyeSpace );
  int Start2ndEye = StartPoint + EyeWidth + EyeSpace;

  for (i = 0; i < EyeWidth; i++) {
    setPixel(StartPoint + i, red, green, blue);
    setPixel(Start2ndEye + i, red, green, blue);
  }

  showStrip();

  if (Fade == true) {
    float r, g, b;

    for (int j = Steps; j >= 0; j--) {
      r = j * (red / Steps);
      g = j * (green / Steps);
      b = j * (blue / Steps);

      for (i = 0; i < EyeWidth; i++) {
        setPixel(StartPoint + i, r, g, b);
        setPixel(Start2ndEye + i, r, g, b);
      }

      showStrip();
      delay(FadeDelay);
    }
  }

  setAll(0, 0, 0); // Set all black

  delay(EndPause);
}

void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {

  for (int i = 0; i < NUM_LEDS - EyeSize - 2; i++) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }

  delay(ReturnDelay);

  for (int i = NUM_LEDS - EyeSize - 2; i > 0; i--) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }

  delay(ReturnDelay);
}

void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
}

// used by NewKITT
void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = ((NUM_LEDS - EyeSize) / 2); i >= 0; i--) {
    setAll(0, 0, 0);

    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);

    setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS - i - j, red, green, blue);
    }
    setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10);

    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

// used by NewKITT
void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = 0; i <= ((NUM_LEDS - EyeSize) / 2); i++) {
    setAll(0, 0, 0);

    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);

    setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS - i - j, red, green, blue);
    }
    setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10);

    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

// used by NewKITT
void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = 0; i < NUM_LEDS - EyeSize - 2; i++) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

// used by NewKITT
void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = NUM_LEDS - EyeSize - 2; i > 0; i--) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void Twinkle(byte red, byte green, byte blue, int Count, int SpeedDelay, boolean OnlyOne) {
  setAll(0, 0, 0);

  for (int i = 0; i < Count; i++) {
    setPixel(random(NUM_LEDS), red, green, blue);
    showStrip();
    delay(SpeedDelay);
    if (OnlyOne) {
      setAll(0, 0, 0);
    }
  }

  delay(SpeedDelay);
}

void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {
  setAll(0, 0, 0);

  for (int i = 0; i < Count; i++) {
    setPixel(random(NUM_LEDS), random(0, 255), random(0, 255), random(0, 255));
    showStrip();
    delay(SpeedDelay);
    if (OnlyOne) {
      setAll(0, 0, 0);
    }
  }

  delay(SpeedDelay);
}

void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  int Pixel = random(NUM_LEDS);
  setPixel(Pixel, red, green, blue);
  showStrip();
  delay(SpeedDelay);
  setPixel(Pixel, 0, 0, 0);
}

void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {
  setAll(red, green, blue);

  int Pixel = random(NUM_LEDS);
  setPixel(Pixel, 0xff, 0xff, 0xff);
  showStrip();
  delay(SparkleDelay);
  setPixel(Pixel, red, green, blue);
  showStrip();
  delay(SpeedDelay);
}

void RunningLights(byte red, byte green, byte blue, int WaveDelay) {
  int Position = 0;

  for (int i = 0; i < NUM_LEDS * 2; i++)
  {
    Position++; // = 0; //Position + Rate;
    for (int i = 0; i < NUM_LEDS; i++) {
      // sine wave, 3 offset waves make a rainbow!
      //float level = sin(i+Position) * 127 + 128;
      //setPixel(i,level,0,0);
      //float level = sin(i+Position) * 127 + 128;
      setPixel(i, ((sin(i + Position) * 127 + 128) / 255)*red,
               ((sin(i + Position) * 127 + 128) / 255)*green,
               ((sin(i + Position) * 127 + 128) / 255)*blue);
    }

    showStrip();
    delay(WaveDelay);
  }
}

void colorWipe(byte red, byte green, byte blue, int SpeedDelay) {
  for (uint16_t i = 0; i < NUM_LEDS; i++) {
    setPixel(i, red, green, blue);
    showStrip();
    delay(SpeedDelay);
  }
}

void rainbowCycle(int SpeedDelay) {
  byte *c;
  uint16_t i, j;

  for (j = 0; j < 256 * 5; j++) { // 5 cycles of all colors on wheel
    for (i = 0; i < NUM_LEDS; i++) {
      c = Wheel(((i * 256 / NUM_LEDS) + j) & 255);
      setPixel(i, *c, *(c + 1), *(c + 2));
    }
    showStrip();
    delay(SpeedDelay);
  }
}

// used by rainbowCycle and theaterChaseRainbow
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;
}

void theaterChase(byte red, byte green, byte blue, int SpeedDelay) {
  for (int j = 0; j < 10; j++) { //do 10 cycles of chasing
    for (int q = 0; q < 3; q++) {
      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        setPixel(i + q, red, green, blue);  //turn every third pixel on
      }
      showStrip();

      delay(SpeedDelay);

      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        setPixel(i + q, 0, 0, 0);    //turn every third pixel off
      }
    }
  }
}

void theaterChaseRainbow(int SpeedDelay) {
  byte *c;

  for (int j = 0; j < 256; j++) {   // cycle all 256 colors in the wheel
    for (int q = 0; q < 3; q++) {
      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        c = Wheel( (i + j) % 255);
        setPixel(i + q, *c, *(c + 1), *(c + 2)); //turn every third pixel on
      }
      showStrip();

      delay(SpeedDelay);

      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        setPixel(i + q, 0, 0, 0);    //turn every third pixel off
      }
    }
  }
}

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
    setPixel(Pixel, 255, 255, heatramp);
  } else if ( t192 > 0x40 ) {            // middle
    setPixel(Pixel, 255, heatramp, 0);
  } else {                               // coolest
    setPixel(Pixel, heatramp, 0, 0);
  }
}

void BouncingColoredBalls(int BallCount, byte colors[][3], boolean continuous) {
  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];
  boolean ballBouncing[BallCount];
  boolean ballsStillBouncing = true;

  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);
    ballBouncing[i] = true;
  }

  while (ballsStillBouncing) {
    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 ) {
          if (continuous) {
            ImpactVelocity[i] = ImpactVelocityStart;
          } else {
            ballBouncing[i] = false;
          }
        }
      }
      Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);
    }

    ballsStillBouncing = false; // assume no balls bouncing
    for (int i = 0 ; i < BallCount ; i++) {
      setPixel(Position[i], colors[i][0], colors[i][1], colors[i][2]);
      if ( ballBouncing[i] ) {
        ballsStillBouncing = true;
      }
    }

    showStrip();
    setAll(0, 0, 0);
  }
}

void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {
  setAll(0, 0, 0);

  for (int i = 0; i < NUM_LEDS + NUM_LEDS; i++) {


    // fade brightness all LEDs one step
    for (int j = 0; j < NUM_LEDS; j++) {
      if ( (!meteorRandomDecay) || (random(10) > 5) ) {
        fadeToBlack(j, meteorTrailDecay );
      }
    }

    // draw meteor
    for (int j = 0; j < meteorSize; j++) {
      if ( ( i - j < NUM_LEDS) && (i - j >= 0) ) {
        setPixel(i - j, red, green, blue);
      }
    }

    showStrip();
    delay(SpeedDelay);
  }
}

// used by meteorrain
void fadeToBlack(int ledNo, byte fadeValue) {
  // FastLED
  leds[ledNo].fadeToBlackBy( fadeValue );
}

// *** REPLACE TO HERE ***



// ***************************************
// ** FastLed/NeoPixel Common Functions **
// ***************************************

// Apply LED color changes
void showStrip() {
  FastLED.show();
}

// Set a LED color (not yet visible)
void setPixel(int Pixel, byte red, byte green, byte blue) {
  // FastLED
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
}

// Set all LEDs to a given color and apply it (visible)
void setAll(byte red, byte green, byte blue) {
  for (int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue);
  }
  showStrip();
}

Wegen der Nutzung von delay() kann das Umschalten zu einer neuen Animation mehrere Minuten dauern. Man darf also nicht ungeduldig werden

Anm.:

Wenn ich mich nicht verzählt habe

flippo710 · April 6, 2022, 5:23am

Ich hatte mich gestern Abend nochmal reingefuchst und meinen Denkfehler gefunden. Hatte es ziemlich genau so aufgebaut wie du - jetzt scheint es nur noch einen Bug mit dem Encoding/Decoding zu geben. Also Verbindung steht, Wert kommt an, scheint nur flasch codiert zu sein, weil mir der Arduino immer eine Fehlermeldung schickt da ich den Fehler catche, sollte eine Zahl eingegeben werden, die keinem Effekt entspricht. Muss mich nochmal in das Coding und Decoding einlesen, hatte gestern nur keinen Kopf mehr.

Am Arduino kommt nämlich nicht die Zahl 1 - 19 (für die Effekte) an sondern etwas anderes. Kann nur leider die Ausgabe nicht überprüfen da ja mein Python Projekt die COM6 Schnittstelle blockt und ich somit nicht per IDE die Ausgabe direkt des Aurdinos überprüfen kann, oder gibts da ne möglichkeit?

Vielen Dank schonmal in die Runde!

my_xy_projekt · April 6, 2022, 6:10am

eine von den anderen HardwareSerial benutzen und die Eingabe als Kopie auf einen dieser Ports schicken.
Dann hast das Terminal da dran...

agmue · April 6, 2022, 6:12am

Zur Fehlersuche würde ich ein Display anschließen, beispielsweise ein Vierzeiliges I²C LCD Modul oder ein OLED Display.

Der Mega 2560 hat viele serielle Schnittstellen, mit einem USB zu UART TTL Adapter kann man die an USB anschließen. Das habe ich für Deine Konstellation zwar noch nicht probiert, wäre aber einen Versuch wert.

Ein zweiter Arduino wäre auch eine Möglichkeit, schau mal in Deine Bastelkiste, was die so hergibt.

system · October 3, 2022, 6:12am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Lichteffekte einer LED Strips (WS2811) mit dem Arduino wechseln Deutsch	47	1683	March 5, 2023
SAMD21 to WS28212b LEDs and Multiplexing	6	127	July 22, 2025
Arduino und Ws2812 nach Durchgang alles leds aus schalten Deutsch	17	284	October 17, 2025
Projekt WS2812b Deutsch	34	265	January 14, 2025
Led Stripe mit Relais Karte ansteuern Deutsch	49	433	October 23, 2025

PC Beleuchtung per WS2812B und Arduino

Related topics