Go Down

Topic: Zündreihenfolge eines 6 Zylinders simulieren (Read 1 time) previous topic - next topic

agmue

#15
Jul 23, 2018, 06:31 pm Last Edit: Jul 23, 2018, 06:36 pm by agmue
Dani, wo hast Du ein Datenblatt gefunden, das den Controller/LED  RGBW spezifiziert. Ich finde nur GRB LED.
Hallo Uwe, der Link aus #0 führt auf eine Seite, wo ich "Technische Daten Farbe RGBW" finde. Im Datenblatt steht "IC Typ SK6812". Ich habe ein Juwel von Adafruit, sieht auch so aus.

Der ESP8266 verfügt nur über ein WiFi Modul und nicht über Bluetooth. der ESP32 beinhaltet beides.
Danke!
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

postmaster-ino

Hi
oder hier ab ca 4:30
https://www.youtube.com/watch?v=rURHVLM9nxs
Eine Idee, warum der Zylinder dort 3 Leer-Hübe macht?

Davon ab - würde der Zündfunke auch von einem Lauflicht simuliert werden können.
Man muß halt die LEDs nicht in der Reihenfolge, in Der Diese aufleuchten, im Motor platzieren, sondern in der Reihenfolge, in Der die Zylinder zünden sollen.
Und Da wäre 1-5-3-6-2-4 möglich (jeweils bei 120° Eins weiter - weitere mögliche Zündreihenfolgen müsste ich er-googeln - denke, als KFZler ist man Da etwas sattelfester ;)

MfG
anscheinend ist Es nicht erwünscht, einen Foren-internen Link als 'Homepage' einzubinden, damit JEDER nur einen Klick von combie's Liste zum Thema State-Maschine entfernt ist.
... dann eben nicht ...

noiasca

8-Takter

^^

OT: im ernst keine Ahnung, ist mir auch aufgefallen. Ich betreibe auch so einen Briggs & Stratton - vieleicht ist das der Grund warum der so schlecht startet ;-)
DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

Yves83

So Jungs,
es hat leider alles etwas länger gedauert. Sorry für die Wartezeit.

Zu meiner Hardware:
LED Ringe sind bekannt.
Es ist jetzt ein ESP32 mit Bluetooth und WLAN geworden.

Die Anbindung steht und ich habe schon die erste Kommunikation zum Board aufgebaut.
Die NeoPixel Bibliothek ist eingepflegt.

Ich würde jetzt am Liebsten mal ein LED Ring anschließen und mit einer Beispielprogrammierung rumspielen.

Könnt ihr mir ein einfaches Script zur Verfügung stellen und einen Pin zuordnen wo z.B. nur ein Ring LED 1-7 angesteuert werden.
LED 1 Rot 5 Sekunden, LED 1 AUS, LED 2 Rot 5 Sekunden, LED 2 AUS und so weiter...


Dann habe ich die Ansteuerung der einzelnen LEDs und ein Zeitwert mit Drinne und kann erstmal etwas rumspielen. Die Farben und die Einbindung der restlichen LED-Ringe würde ich dann machen, wenn die Logik verstanden ist.

Wenn die Ansteuerung dann klappt, würde ich mich um die Ansteuerung der "Programme" über Bluetooth kümmern.

Erstmal Stück für Stück anfangen.

noiasca

da du dich damals nicht mehr gemeldet hast, ging es parallel in einem neuen Thread weiter. Vermutlich hat ihn agmue  begonnen. Suchen musst du den Thread selber. Sind ja nur ein paar Monate zurück.
DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

combie

Schreie nach Besserem, bis du es auch erhältst.
Das noch Bessere verabschiedet sich rechtzeitig vor deinem Lärm.

Quelle: Martin Gerhard Reisenberg

agmue

da du dich damals nicht mehr gemeldet hast, ging es parallel in einem neuen Thread weiter.
Da ich eine OOP-Vorlage von combie mal selbst umsetzen wollte, ging es mir um "richtiges" Programmieren, nicht um die richtige Simulation. Daher fand ich ein eigenes Thema angemessen.

Ich merke mir sowas (manchmal).
Das finde ich süß und denke gleich an Herbstausstellungen mit Probierständen, wo verschiedenste Honigsorten feil geboten werden :smiley-mr-green:

Könnt ihr mir ein einfaches Script zur Verfügung stellen und einen Pin zuordnen wo z.B. nur ein Ring LED 1-7 angesteuert werden.
Du kannst mein Programm nutzen, macht ja ungefähr, was Du möchtest.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

combie

Das finde ich süß und denke gleich an Herbstausstellungen mit Probierständen, wo verschiedenste Honigsorten feil geboten werden :smiley-mr-green:
Für die kommende Wintersaison empfehle ich dir:
Selbst gemahlenen Kakao, in frischem Drüsensekret einer Kuh, kurz aufgekocht, und mit Kastanienhonig gesüßt.


Schreie nach Besserem, bis du es auch erhältst.
Das noch Bessere verabschiedet sich rechtzeitig vor deinem Lärm.

Quelle: Martin Gerhard Reisenberg

agmue

#23
Sep 27, 2018, 12:57 pm Last Edit: Sep 27, 2018, 12:58 pm by agmue
LED 1 Rot 5 Sekunden, LED 1 AUS, LED 2 Rot 5 Sekunden, LED 2 AUS und so weiter...
Code: [Select]
#include <Adafruit_NeoPixel.h>

#define NEOPIN 6
#define ANZAHLDERPIXEL 7
#define BRIGHTNESS 255

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(ANZAHLDERPIXEL, NEOPIN, NEO_GRBW + NEO_KHZ800);

// LED 1 Rot 5 Sekunden, LED 1 AUS, LED 2 Rot 5 Sekunden, LED 2 AUS und so weiter...
unsigned long intervalle[] = {1000, 1000, 1000, 1000, 1000, 1000, 1000};
unsigned long aktMillis, ablaufMillis;
byte lednummer = 0;

void setup() {
  strip.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  aktMillis = millis();
  if (aktMillis - ablaufMillis >= intervalle[lednummer]) {
    ablaufMillis = aktMillis;
    strip.setPixelColor(lednummer, strip.Color(0, 0, 0, 0));
    lednummer = (lednummer + 1) % ANZAHLDERPIXEL;
    strip.setPixelColor(lednummer, strip.Color(255, 0, 0, 0));
    strip.show();
  }
}


Selbst gemahlenen Kakao, in frischem Drüsensekret einer Kuh, kurz aufgekocht, und mit Kastanienhonig gesüßt.
Ja, das kann ich mir vorstellen. Ob die lokalen Imker Kastanienhonig im Sortiment führen, finde ich heraus, nur würde es derzeit am selber Mahlen scheitern. Aber ich kenne ein inhabergeführtes Haushaltswarengeschäft, da findet man verschiedenste Dinge. Mal sehen, danke für den Tipp!
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Yves83

Moin Jungs,
ich habe folgendes Programm auf meinen Nano gespielt.

Zur Hardware:
Ich benutze Pin22 für die Ansteuerung.
Habe einen 100uF Kondensator zwischen + und - der Spannungsversorgung geklemmt und einen 220 Ohm Widerstand in Reihe mit der Signalleitung.
Irgendwo ist noch der Wurm drinne.



Code: [Select]

// Variante für RGB anstelle RGBW
#include <Adafruit_NeoPixel.h>

#define NEOPIN 6
#define ANZAHLDERPIXEL 42  // hier müßte 42 stehen
#define PIXELPROZYL 7     // hier müßte 7 stehen
#define BRIGHTNESS 255

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(ANZAHLDERPIXEL, NEOPIN, NEO_RGB + NEO_KHZ800);

const unsigned long intervalle[] = {10, 50, 10, 500};
unsigned long aktMillis;

void setup() {
  strip.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

struct Fade  // Für jede Farbe wird ein Startwert (0-255, 0=dunkel, 255=hell) angegeben, der mit dem Fadewert jedes Intervall (in ms) verändert wird.
             // start() setzt die Startwerte, run() macht das Faden.
             // Der Rückgabewert ist true, wenn alle Farben so nahe an 0 oder 255 sind, daß sie nicht mehr verändert werden können.
{
  Fade(byte rot, int8_t rotfade, byte gruen, int8_t gruenfade, byte blau, int8_t blaufade, uint32_t intervall):
    rot(rot), rotfade(rotfade), gruen(gruen), gruenfade(gruenfade), blau(blau), blaufade(blaufade), intervall(intervall), ablaufMillis(0) {}

  void start(byte ersterpixel)
  {
    ep = ersterpixel;
    r = rot;
    rf = rotfade;
    g = gruen;
    gf = gruenfade;
    b = blau;
    bf = blaufade;
    i = intervall;
    ablaufMillis = aktMillis;
    for (byte pixel = ep; pixel < ep + PIXELPROZYL; pixel++)
    {
      strip.setPixelColor(pixel, strip.Color(r, g, b));
    }
    strip.show();
  }

  bool run()
  {
    bool rueckgabe = false;
    if (aktMillis - ablaufMillis >= i)
    {
      ablaufMillis = aktMillis;
      if (r >= -rf) r += rf;
      if (g >= -gf) g += gf;
      if (b >= -bf) b += bf;
      for (byte pixel = ep; pixel < ep + PIXELPROZYL; pixel++)
      {
        strip.setPixelColor(pixel, strip.Color(r, g, b));
      }
      strip.show();
      if ((r <= -rf || r > 255 - rf) && (g <= -gf || g > 255 - gf) && (b <= -bf || b > 255 - bf))
      {
        rueckgabe = true;
      }
    }
    return rueckgabe;
  }
  byte rot; int8_t rotfade; byte gruen; int8_t gruenfade; byte blau; int8_t blaufade; uint32_t intervall;

  byte ep;
  byte r;
  int8_t rf;
  byte g;
  int8_t gf;
  byte b;
  int8_t bf;
  byte i;
  unsigned long ablaufMillis;
};
Fade fade[]
{ // rot, rotfade, gruen, gruenfade, blau, blaufade, intervall
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
};

struct Zyl  // Durchläuft die Schritte einer Schrittkette, wobei jeder Schritt dem Takt eines 4-Takt-Otto-Motors entsprechen könnte,
            // was hier aber eher künstlerisch zu betrachten ist.
            // startphase: Bei welchem Schritt (Takt) die Animation beginnt.
            // startpixel: Erstes Pixel für den Zylinder. Bei 42 Pixeln 0, 7, 14 ...
            // fadetyp: Notwendig, damit sich die Fadephasen nicht in die Quere kommen.
{
  Zyl(const byte startphase, const byte startpixel, const byte fadetyp): schritt(startphase), startpixel(startpixel), fadetyp(fadetyp), einmal(true), ablaufMillis(0) {}
  void run()
  {
    switch (schritt) {  // schritt würde dem Takt eines 4-Takt-Otto-Motors entsprechen.
      case 0:  // Blau von 0 nach 255 faden
        if (einmal) {
          einmal = false;
          fade[fadetyp].start(startpixel);
        } else {
          if (fade[fadetyp].run()) {
            schritt++;
            einmal = true;
          }
          break;
        case 1:  // ein weißer Blitz
          if (einmal) {
            einmal = false;
            for (byte pixel = startpixel; pixel < startpixel + PIXELPROZYL; pixel++) {
              strip.setPixelColor(pixel, strip.Color(255, 255, 255));
            }
            strip.show();
            ablaufMillis = aktMillis;
          }
          if (aktMillis - ablaufMillis >= intervalle[schritt]) {
            schritt++;
            einmal = true;
          }
          break;
        case 2:  // Rot von 255 nach 0 faden
          if (einmal) {
            einmal = false;
            fade[fadetyp+1].start(startpixel);
          } else {
            if (fade[fadetyp+1].run()) {
              schritt++;
              einmal = true;
            }
          }
          break;
        case 3:  // kurz alle Farben aus
          if (einmal) {
            einmal = false;
            for (byte pixel = startpixel; pixel < startpixel + PIXELPROZYL; pixel++) {
              strip.setPixelColor(pixel, strip.Color(0,   0,   0));
            }
            strip.show();
            ablaufMillis = aktMillis;
          }
          if (aktMillis - ablaufMillis >= intervalle[schritt]) {
            schritt++;
            einmal = true;
          }
          break;
        default:
          schritt = 0;
          break;
        }
    }
  }
  byte schritt;
  const byte startpixel;
  const byte fadetyp;
  bool einmal;
  unsigned long ablaufMillis;
};
Zyl zylinder[]
{ // startphase, startpixel, fadetyp
  {0, 0, 0},
  {2, 1, 2},
  {3, 2, 4},
  {0, 3, 6},
  {2, 4, 8},
  {3, 5, 10}
};

void loop() {
  aktMillis = millis();
  for (Zyl &z : zylinder) z.run();
}



Ich werde das Gefühl nicht los, das ihr andere Hardware benutzt.
Der Sketch "rgbwstrandfest" aus der Adafruit Bibliothek funktioniert ohne Probleme.
Spiele ich aber eins eurer Scripte auf, funktioniert nix mehr.
Habt ihr eine Idee?

combie

Quote
Ich werde das Gefühl nicht los, das ihr andere Hardware benutzt.
Und das wars dann.... ?


Meine Glaskugel schreit:
Ersetze NEO_RGB durch NEO_RGBW
Schreie nach Besserem, bis du es auch erhältst.
Das noch Bessere verabschiedet sich rechtzeitig vor deinem Lärm.

Quelle: Martin Gerhard Reisenberg

Yves83

Danke Combie für den Tip.
Ändert aber leider nix.
Ich habe euch mal das aktuelle Script und ein Video angehängt.

Code: [Select]


// Variante für RGB anstelle RGBW
#include <Adafruit_NeoPixel.h>

#define NEOPIN 6
#define ANZAHLDERPIXEL 42  // hier müßte 42 stehen
#define PIXELPROZYL 7     // hier müßte 7 stehen
#define BRIGHTNESS 255

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(ANZAHLDERPIXEL, NEOPIN, NEO_RGBW + NEO_KHZ800);

const unsigned long intervalle[] = {10, 50, 10, 500};
unsigned long aktMillis;

void setup() {
  strip.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

struct Fade  // Für jede Farbe wird ein Startwert (0-255, 0=dunkel, 255=hell) angegeben, der mit dem Fadewert jedes Intervall (in ms) verändert wird.
             // start() setzt die Startwerte, run() macht das Faden.
             // Der Rückgabewert ist true, wenn alle Farben so nahe an 0 oder 255 sind, daß sie nicht mehr verändert werden können.
{
  Fade(byte rot, int8_t rotfade, byte gruen, int8_t gruenfade, byte blau, int8_t blaufade, uint32_t intervall):
    rot(rot), rotfade(rotfade), gruen(gruen), gruenfade(gruenfade), blau(blau), blaufade(blaufade), intervall(intervall), ablaufMillis(0) {}

  void start(byte ersterpixel)
  {
    ep = ersterpixel;
    r = rot;
    rf = rotfade;
    g = gruen;
    gf = gruenfade;
    b = blau;
    bf = blaufade;
    i = intervall;
    ablaufMillis = aktMillis;
    for (byte pixel = ep; pixel < ep + PIXELPROZYL; pixel++)
    {
      strip.setPixelColor(pixel, strip.Color(r, g, b));
    }
    strip.show();
  }

  bool run()
  {
    bool rueckgabe = false;
    if (aktMillis - ablaufMillis >= i)
    {
      ablaufMillis = aktMillis;
      if (r >= -rf) r += rf;
      if (g >= -gf) g += gf;
      if (b >= -bf) b += bf;
      for (byte pixel = ep; pixel < ep + PIXELPROZYL; pixel++)
      {
        strip.setPixelColor(pixel, strip.Color(r, g, b));
      }
      strip.show();
      if ((r <= -rf || r > 255 - rf) && (g <= -gf || g > 255 - gf) && (b <= -bf || b > 255 - bf))
      {
        rueckgabe = true;
      }
    }
    return rueckgabe;
  }
  byte rot; int8_t rotfade; byte gruen; int8_t gruenfade; byte blau; int8_t blaufade; uint32_t intervall;

  byte ep;
  byte r;
  int8_t rf;
  byte g;
  int8_t gf;
  byte b;
  int8_t bf;
  byte i;
  unsigned long ablaufMillis;
};
Fade fade[]
{ // rot, rotfade, gruen, gruenfade, blau, blaufade, intervall
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, intervalle[0]},
  {255, -1, 0, 0, 0, 0, intervalle[2]},
};

struct Zyl  // Durchläuft die Schritte einer Schrittkette, wobei jeder Schritt dem Takt eines 4-Takt-Otto-Motors entsprechen könnte,
            // was hier aber eher künstlerisch zu betrachten ist.
            // startphase: Bei welchem Schritt (Takt) die Animation beginnt.
            // startpixel: Erstes Pixel für den Zylinder. Bei 42 Pixeln 0, 7, 14 ...
            // fadetyp: Notwendig, damit sich die Fadephasen nicht in die Quere kommen.
{
  Zyl(const byte startphase, const byte startpixel, const byte fadetyp): schritt(startphase), startpixel(startpixel), fadetyp(fadetyp), einmal(true), ablaufMillis(0) {}
  void run()
  {
    switch (schritt) {  // schritt würde dem Takt eines 4-Takt-Otto-Motors entsprechen.
      case 0:  // Blau von 0 nach 255 faden
        if (einmal) {
          einmal = false;
          fade[fadetyp].start(startpixel);
        } else {
          if (fade[fadetyp].run()) {
            schritt++;
            einmal = true;
          }
          break;
        case 1:  // ein weißer Blitz
          if (einmal) {
            einmal = false;
            for (byte pixel = startpixel; pixel < startpixel + PIXELPROZYL; pixel++) {
              strip.setPixelColor(pixel, strip.Color(255, 255, 255));
            }
            strip.show();
            ablaufMillis = aktMillis;
          }
          if (aktMillis - ablaufMillis >= intervalle[schritt]) {
            schritt++;
            einmal = true;
          }
          break;
        case 2:  // Rot von 255 nach 0 faden
          if (einmal) {
            einmal = false;
            fade[fadetyp+1].start(startpixel);
          } else {
            if (fade[fadetyp+1].run()) {
              schritt++;
              einmal = true;
            }
          }
          break;
        case 3:  // kurz alle Farben aus
          if (einmal) {
            einmal = false;
            for (byte pixel = startpixel; pixel < startpixel + PIXELPROZYL; pixel++) {
              strip.setPixelColor(pixel, strip.Color(0,   0,   0));
            }
            strip.show();
            ablaufMillis = aktMillis;
          }
          if (aktMillis - ablaufMillis >= intervalle[schritt]) {
            schritt++;
            einmal = true;
          }
          break;
        default:
          schritt = 0;
          break;
        }
    }
  }
  byte schritt;
  const byte startpixel;
  const byte fadetyp;
  bool einmal;
  unsigned long ablaufMillis;
};
Zyl zylinder[]
{ // startphase, startpixel, fadetyp
  {0, 0, 0},
  {2, 1, 2},
  {3, 2, 4},
  {0, 3, 6},
  {2, 4, 8},
  {3, 5, 10}
};

void loop() {
  aktMillis = millis();
  for (Zyl &z : zylinder) z.run();
}




Hier das Video:
Zündung Sechszylinder

agmue

Ändert aber leider nix.
Das IC im RGB-Pixel möchte drei Bytes Informationen haben, das im RGBW-Pixel dagegen vier. Daher wird aus

setPixelColor(pixel, strip.Color(r, g, b)) dann

setPixelColor(pixel, strip.Color(r, g, b, w))

In meinem Thema habe ich mit einer Variante für RGBW angefangen, probiere die doch mal.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Yves83

#28
Nov 07, 2018, 02:28 pm Last Edit: Nov 07, 2018, 02:46 pm by Yves83
Es hat funktioniert.... :smiley-grin:

Code: [Select]
#include <Adafruit_NeoPixel.h>

#define NEOPIN 22
#define ANZAHLDERPIXEL 42  // hier müßte 42 stehen
#define PIXELPROZYL 7     // hier müßte 7 stehen
#define BRIGHTNESS 255

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(ANZAHLDERPIXEL, NEOPIN, NEO_GRBW + NEO_KHZ800);

const unsigned long intervalle[] = {10, 50, 10, 500};
unsigned long aktMillis;

void setup() {
  strip.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

struct Fade  // Für jede Farbe wird ein Startwert (0-255, 0=dunkel, 255=hell) angegeben, der mit dem Fadewert jedes Intervall (in ms) verändert wird.
             // start() setzt die Startwerte, run() macht das Faden.
             // Der Rückgabewert ist true, wenn alle Farben so nahe an 0 oder 255 sind, daß sie nicht mehr verändert werden können.
{
  Fade(byte rot, int8_t rotfade, byte gruen, int8_t gruenfade, byte blau, int8_t blaufade, byte weiss, int8_t weissfade, uint32_t intervall):
    rot(rot), rotfade(rotfade), gruen(gruen), gruenfade(gruenfade), blau(blau), blaufade(blaufade), weiss(weiss), weissfade(weissfade), intervall(intervall), ablaufMillis(0) {}

  void start(byte ersterpixel)
  {
    ep = ersterpixel;
    r = rot;
    rf = rotfade;
    g = gruen;
    gf = gruenfade;
    b = blau;
    bf = blaufade;
    w = weiss;
    wf = weissfade;
    i = intervall;
    ablaufMillis = aktMillis;
    for (byte pixel = ep; pixel < ep + PIXELPROZYL; pixel++)
    {
      strip.setPixelColor(pixel, strip.Color(r, g, b, w));
    }
    strip.show();
  }

  bool run()
  {
    bool rueckgabe = false;
    if (aktMillis - ablaufMillis >= i)
    {
      ablaufMillis = aktMillis;
      if (r >= -rf) r += rf;
      if (g >= -gf) g += gf;
      if (b >= -bf) b += bf;
      if (w >= -wf) w += wf;
      for (byte pixel = ep; pixel < ep + PIXELPROZYL; pixel++)
      {
        strip.setPixelColor(pixel, strip.Color(r, g, b, w));
      }
      strip.show();
      if ((r <= -rf || r > 255 - rf) && (g <= -gf || g > 255 - gf) && (b <= -bf || b > 255 - bf) && (w <= -wf || w > 255 - wf))
      {
        rueckgabe = true;
      }
    }
    return rueckgabe;
  }
  byte rot; int8_t rotfade; byte gruen; int8_t gruenfade; byte blau; int8_t blaufade; byte weiss; int8_t weissfade; uint32_t intervall;

  byte ep;
  byte r;
  int8_t rf;
  byte g;
  int8_t gf;
  byte b;
  int8_t bf;
  byte w;
  int8_t wf;
  byte i;
  unsigned long ablaufMillis;
};
Fade fade[]
{ // rot, rotfade, gruen, gruenfade, blau, blaufade, weiss, weissfade, intervall
  {0, 0, 0, 0, 0, 1, 0, 0, intervalle[0]},
  {255, -1, 0, 0, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, 0, 0, intervalle[0]},
  {255, -1, 0, 0, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, 0, 0, intervalle[0]},
  {255, -1, 0, 0, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, 0, 0, intervalle[0]},
  {255, -1, 0, 0, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, 0, 0, intervalle[0]},
  {255, -1, 0, 0, 0, 0, 0, 0, intervalle[2]},
  {0, 0, 0, 0, 0, 1, 0, 0, intervalle[0]},
  {255, -1, 0, 0, 0, 0, 0, 0, intervalle[2]},
};

struct Zyl  // Durchläuft die Schritte einer Schrittkette, wobei jeder Schritt dem Takt eines 4-Takt-Otto-Motors entsprechen könnte,
            // was hier aber eher künstlerisch zu betrachten ist.
            // startphase: Bei welchem Schritt (Takt) die Animation beginnt.
            // startpixel: Erstes Pixel für den Zylinder. Bei 42 Pixeln 0, 7, 14 ...
            // fadetyp: Notwendig, damit sich die Fadephasen nicht in die Quere kommen.
{
  Zyl(const byte startphase, const byte startpixel, const byte fadetyp): schritt(startphase), startpixel(startpixel), fadetyp(fadetyp), einmal(true), ablaufMillis(0) {}
  void run()
  {
    switch (schritt) {  // schritt würde dem Takt eines 4-Takt-Otto-Motors entsprechen.
      case 0:  // Blau von 0 nach 255 faden
        if (einmal) {
          einmal = false;
          fade[fadetyp].start(startpixel);
        } else {
          if (fade[fadetyp].run()) {
            schritt++;
            einmal = true;
          }
          break;
        case 1:  // zusätzlich zu Blau ein weißer Blitz
          if (einmal) {
            einmal = false;
            for (byte pixel = startpixel; pixel < startpixel + PIXELPROZYL; pixel++) {
              strip.setPixelColor(pixel, strip.Color(0,   0,   255, 255));
            }
            strip.show();
            ablaufMillis = aktMillis;
          }
          if (aktMillis - ablaufMillis >= intervalle[schritt]) {
            schritt++;
            einmal = true;
          }
          break;
        case 2:  // Rot von 255 nach 0 faden
          if (einmal) {
            einmal = false;
            fade[fadetyp+1].start(startpixel);
          } else {
            if (fade[fadetyp+1].run()) {
              schritt++;
              einmal = true;
            }
          }
          break;
        case 3:  // kurz alle Farben aus
          if (einmal) {
            einmal = false;
            for (byte pixel = startpixel; pixel < startpixel + PIXELPROZYL; pixel++) {
              strip.setPixelColor(pixel, strip.Color(0,   0,   0,   0));
            }
            strip.show();
            ablaufMillis = aktMillis;
          }
          if (aktMillis - ablaufMillis >= intervalle[schritt]) {
            schritt++;
            einmal = true;
          }
          break;
        default:
          schritt = 0;
          break;
        }
    }
  }
  byte schritt;
  const byte startpixel;
  const byte fadetyp;
  bool einmal;
  unsigned long ablaufMillis;
};
Zyl zylinder[]
{ // startphase, startpixel, fadetyp
  {0, 0, 0},
  {2, 7, 2},
  {3, 14, 4},
  {0, 21, 6},
  {2, 28, 8},
  {3, 35, 10}
};

void loop() {
  aktMillis = millis();
  for (Zyl &z : zylinder) z.run();
}



Leider habe ich noch ein paar grüne Pixel drinne, aber auch nur sporadisch.
Habe die Datenleitung durchverlötet, aber noch immer grüne Pixel.

Zündung 3

Kann es damit zu tun haben , das der esp32 mit 3,3V läuft und die LED mit 5V?
Hab da mal was gelesen, wegen Problemen mit dem Signal und einem Bauteil, was zwischen Signalleitung und erstem Pixel geschaltet werden muss, wenn die Versorgungsspannungen unterschiedlich sind.

agmue

Kann es damit zu tun haben , das der esp32 mit 3,3V läuft und die LED mit 5V?
Ja, der ESP macht mit 3,3V ein Signal außerhalb der LED-Spezifikation. Meist geht das gut, aber bei längeren Kabeln vom ESP zum ersten Pixel kann es dann schon zu Störungen kommen.

Für meinen Teensy (auch 3,3V) habe ich ein 74LS245N als Levelshifter dazwischen. Wäre einen Versuch wert.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Go Up