Go Down

Topic: OOP mit einem Kringel zu viel? (Read 1 time) previous topic - next topic

Yves83

 :smiley-grin:
Ich raste aus, es funktioniert. Geil!


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();
}


Ich habe leider noch immer Ab und Zu grüne Punkte drinne.
Sollte ich bei 42 Pixeln schon von beiden Seiten einspeisen?


agmue

#31
Nov 07, 2018, 01:00 pm Last Edit: Nov 07, 2018, 03:05 pm by agmue
:smiley-grin:
Ich raste aus, es funktioniert. Geil!
:D

Spendierst Du mir ein Video?

Ich habe leider noch immer Ab und Zu grüne Punkte drinne.
Sollte ich bei 42 Pixeln schon von beiden Seiten einspeisen?
Du hast doch die Juwelen oder irre ich mich? Wie willst Du da von "zwei Seiten" einspeisen?

Ich tippe eher auf die Datenleitung, Wackler im Steckbrett mag die überhaupt nicht. Hast Du schon verlötet? Mach mal ein Foto oder Video, dann sieht man eventuell mehr.

Möglicherweise könntest Du jetzt auch wieder in Dein eigenes Thema zurückkehren, da es mir in meinem Thema eigentlich um das Programmieren geht.

EDIT: Hier geht's zum Thema Zündreihenfolge eines 6 Zylinders simulieren
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Go Up