Array Hilfe benötigt (4 Leds variabel dimmen)

Hey Forum!

Eines vor weg: Ich bin absoluter Anfänger,! Das hier ist mein dritter Sketch und ich bin wirklich bemüht mich einzulesen, alles zu verstehen und die Beispiele Codes usw. zu nutzen. Leider komme ich gerade nicht weiter....

Ich möchte 4 LEDs gleichzeitig ansteuern. Alle LEDs sollen zufällig langsam aufleuchten und wieder langsam aus gehen. Dazwischen sollen ebenfalls zufällige Pausen sein (sowohl wenn die LEDs dunkel als auch wenn sie hell sind). Ich habe das Ganze für eine LED erfolgreich geschrieben, aber nachdem ich ein Array eingefügt habe, damit alle 4 LEDs gleichzeitig angesprochen werden funktioniert mein Sketch irgendwie nicht mehr... Da ist alles durcheinander was die Dimmvorgänge angeht.

Ich würde mich sehr freuen wenn mich jemand unterstützen könnte, da mir anscheinend das logische Verständnis fehlt...

Und wenn noch jemand eine Idee hat wie ich das Dimmen etwas samfter (bei niedriger Helligkeit) hinbekommen bin ich auch da offen für alles!

//Arduino Nano 4 variable Kanäle zum Dimmen (entweder LEDS oder Transistoren mit mehreren LEDS)
//PWM Pins 3,5,6,9


const int LEDs[] = {3, 5, 6, 9};          // verwendete Pins (PWM) für die LEDs
byte Status = 0;                          // LED Status auf 0 setzetn (0=hochdimmen 1= runter dimmen)

unsigned long Pause;                      // Variable: Pause zwischen den Dimmvorgängen
const long PMin = 1000;                   // kürzester Intervall
const long PMax = 10000;                  // längster Intervall

unsigned long PWMMin;                     // minimale Helligkeit
unsigned long PWMMax;                     // maximale Helligkeit

unsigned long DimAnfang;                  // Dimvorgang Startzeit
unsigned long DimDurchgang;               // Dimvorgang Gesamtdauer
const long DimMin = 1000;                 // kürzeste Dimmzeit
const long DimMax = 100000;               // längste Dimmzeit
unsigned long DimEnde;                    // Dimmvorgang Endzeitpunkt

unsigned long LetzterDurchgang = 0;       // Zeitpunkt des Letzten Dimmvorgangs
unsigned long Jetzt;                      // Variable für den aktuellen Zeitpunkt
int Helligkeit;                           // Variable für die LED Helligkeit

void setup() {
  Serial.begin(9600);                      // Seriellen Monitor aktivieren
  for (int Pins = 0; Pins < 4; Pins++) {   // LED Pins als Ausgang definieren
    pinMode(LEDs[Pins], OUTPUT);
    randomSeed(analogRead(1));               // start der Zufallszahlen Reihenvolge durch Rauschen des Analogen Eingang 1 vorgeben
    Pause = 0;                               // den ersten Pausedurchgang auf 0 setzen
    Jetzt = millis();                        // der Variable Jetzt den aktuellen Zeitwert übergeben
  }
}


void loop() {
  PWMMin = random(0, 3);                    // zufälliger Wert für geringste Helligkeit
  PWMMax = random(100, 256);                // zufälliger Wert für die höchste Helligkeit
  Jetzt = millis();                         // der Variable Jetzt den aktuellen Zeitwert übergeben

  //Serial.println((LetzterDurchgang + Pause) - Jetzt);
  //Serial.println(Status);
  //Serial.println(LetzterDurchgang);


  for (int Pins = 0; Pins < 4; Pins++) {                           //Alle LEDs ansprechen
    if (Jetzt - LetzterDurchgang >= Pause) {                       // Wenn der letze Durchgang länger her ist als die vorgegebene Pausenzeit dann...

    //hoch dimmen:
      if (Status == 0) {                                           // Wenn die LED runter gedimmt ist dann...
        DimAnfang = Jetzt;                                         // Anfang des Dimmvorgangs als jetzt definieren
        DimDurchgang = random(DimMin, DimMax);                     // Zufällige länge des Dimmvorgangs definieren 
        DimEnde = DimAnfang + DimDurchgang;                        // Zeit bis zum Ende des Dimvorgangs berechnen
        for (long Dim = DimAnfang; Dim < DimEnde; Dim++) {         // hoch dimmen 
          Helligkeit = map(Dim, DimAnfang, DimEnde, 0, 255);       // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 10 sowie Endintensität 255 zwischen 220 und 255)
          analogWrite(LEDs[Pins], Helligkeit);                     // Helligkeit der LED aktualisieren                                                                
          Status = 1;                                              // LED Status auf 1 für runter dimmen setzen
          //Serial.println(Helligkeit);
        }
      }


    // runter dimmen
      else      if (Status == 1) {                                  // Wenn die LED hoch gedimmt ist dann...
        DimAnfang = Jetzt;                                          // Anfang des Dimmvorgangs als jetzt definieren
        DimDurchgang = random(DimMin, DimMax);                      // Zufällige länge des Dimmvorgangs definieren 
        DimEnde = DimAnfang + DimDurchgang;                         // Zeit bis zum Ende des Dimvorgangs berechnen
        for (long Dim = DimEnde; Dim > DimAnfang; Dim--) {          // runter dimmen 
          Helligkeit = map(Dim, DimAnfang, DimEnde, 0, 255);        // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
          analogWrite(LEDs[Pins], Helligkeit);                      // Helligkeit der LED aktualisierenStatus = 1;                                                                für runterdimmen setzen
          Status = 0;                                               // LED Status auf 0 für hoch dimmen setzen
          //Serial.println(Helligkeit);
        }
      }
      LetzterDurchgang = millis();                                  // Zeit für letzten Durchgang aktualisieren
      Pause = random(PMin, PMax);                                   // neuer Zufallswert für die nächste Pause
    }
  }
}

Ich fange mal mit dem gleichmäßigen Dimmen/Faden an. Da gibt es beim Microcontroller-Forum einen guten Artikel dazu.

Zu Deinem anderen Problem:

Jede LED braucht die Infos zu aktuellerWert, lastMilli9s, intervall, Richtung (heller oder dunkler). Die solltest Du in einer Struktur halten und dann ein Array daraus machen:

const uint8_t anzLED = 4; // Anzahl der LED

struct eineLED {
  uint32_t lastMillis;
  uint32_t intervall;
  uint16_t aktWert;
  boolean upwards = true;  // Defaultwert erst mal aufwärts, also heller 
};

eineLED ledArray[anzLED];

Ungetestet, so in der Richtung würde ich es mir vorstellen. Wenn ich was vergessen habe, bitte korrigieren.

Gruß Tommy

Hey Tommy, Danke für die Hilfe. Den Artikel habe ich gelesen bin mir aber nicht sicher ob ich das nun richtig verstanden habe. Ist es richtig, dass der Arduino nur 265 Schritte zur verfügung hat aber wenn ich die Zunahme linear möchte, dann kann ich effektiv nur 32 Schritte nutzen?

Dann würden die Schritte aber noch hackeliger aussehen da der Dimmvorgang später auch gerne mehrere Minuten dauern darf.

Das mit der Struktur habe ich noch nirgendwo bisher gelesen, ich habe schon angefangen zu googeln, aber noch kein Beispiel gefunden das ich mit meinen begrenzten Fähigkeiten adaptieren konnte. Verstanden (inhaltlich und logisch) habe ich allerdings was mein Problem ist. Nun gucke ich ob ich es umgesetzt bekomme und werde parallel dazu hier rein gucken falls es neue infos oder Code Beispiele gibt.

VIELEN DANK schon jetzt!

Probiere die Werte doch einfach mal aus. Dann wirst Du sehen, dass die ziemlich harmonisch sind. Mehr ist mit 8 Bit halt nicht drin. Mich hat der gute Verlauf auch positiv überrascht.

Ansonsten musst Du externe Hardware nehmen, die z.B. 10 oder 12 Bit kann.

Gruß Tommy

Edit: z.B. sowas

Hi

Packe Dir das Struct von Tommy Mal in Deinen Code.
Bei 4 eingetragenen LEDs hat Dein Array die Nummern 0...3 (also Null bis '4 minus 1').

'eineLED' ist der Datentyp, Der eben aus den vier Einzel-Variablen besteht.

ledArray[0].lastMillis ist dann der Wert, an Dem der letzte Dimmschritt gegeben wurde.
Alle 'ledArray[0].interval' ms gehst Du einen Schritt weiter, änderst den .lastMillis, den .aktWert.

Wenn Du am Ende bist, die Richtung 'umdrehen' und 'goto 10' (Alles von Vorne).

Mit dem Struct hast Du alle Werte,Die die LED ausmacht, zusammen und kannst gezielt darauf zugreifen.

Hier wäre schön, wenn Tommy56 noch eine Zuweisung in den Schnipped aufgenommen hätte, mit dem 'ledArray[0].lastMillis' bin ich mir nicht sicher (und heute werfe ich die IDE nicht mehr an).

MfG

Es wäre für die Ratsuchenden schön, wenn Du nicht immer so unpassende Sachen wie "goto 10" einflechten würdest. Dieses Mal steht kein "Wenn" davor.

Gruß Tommy

So....

Ich bin schon sehr am verzweifeln wenn ich ehrlich bin weil ich leider zu blöde bin (obwohl ich mich bis 1 Uhr Abends versucht habe einzulesen und einiges ausprobiert habe) die abgespeicherten Daten aus dem PROGMEM auszulesen. Ich bekomme nur komische Zahlen ausgelesen, die hinten und Vorne nicht passen...

Aus diesem Grund habe ich mich dem Struct Befehl bis jetzt gewidmet. Ich habe ihn verstanden und versucht ihn anzuwenden. Dabei habe ich den Sketch auch etwas umgestellt aber leider bleiben jetzt alle LEDs aus...

//Arduino Nano 4 variable Kanäle zum Dimmen (entweder LEDS oder Transistoren mit mehreren LEDS)
//PWM Pins 3,5,6,9

const uint8_t anzLED = 4;                   // Anzahl der LED
char N;                                     // Variable für die aktive LED
const int LEDs[4] = {3, 5, 6, 9};           // verwendete Pins (PWM) für die LEDs

struct eineLED                              // Eigenschaften der LEDs definieren:
{
  boolean dunkel = true;                    // LED Status definieren (dunkel oder hell)

  unsigned long Pause = 0;                  // Variable: Pause zwischen den Dimmvorgängen
  const long PMin = 1000;                   // kürzester Intervall
  const long PMax = 10000;                  // längster Intervall

  unsigned long PWMMin;                     // minimale Helligkeit
  unsigned long PWMMax;                     // maximale Helligkeit

  unsigned long Dim;                        // Dim Variable
  unsigned long DimAnfang;                  // Dimvorgang Startzeit
  unsigned long DimDurchgang;               // Dimvorgang Gesamtdauer
  const long DimMin = 1000;                 // kürzeste Dimmzeit
  const long DimMax = 100000;               // längste Dimmzeit
  unsigned long DimEnde;                    // Dimmvorgang Endzeitpunkt

  unsigned long LetzterDurchgang = 0;       // Zeitpunkt des Letzten Dimmvorgangs
  unsigned long Jetzt;                      // Variable für den aktuellen Zeitpunkt
  int Helligkeit;                           // Variable für die LED Helligkeit
};

eineLED LED[anzLED];                        // 4 Leds Generieren

void setup() {
  Serial.begin(9600);                       // Seriellen Monitor aktivieren
  for (int Pins = 0; Pins < 4; Pins++) {    // LED Pins als Ausgang definieren
    pinMode(LEDs[Pins], OUTPUT);
  }
  for (int x = 0; x < 4; x++) {             // Pausenwert für alle LEDs auf 0 setzen
    LED[x].Pause = 0;
  }
  randomSeed(analogRead(1));                // start der Zufallszahlen Reihenvolge durch Rauschen des Analogen Eingang 1 vorgeben
}


void loop() {

  LED[N].Jetzt = millis();                                          // der Variable Jetzt den aktuellen Zeitwert übergeben
  N = random(0, 3);                                                 // Zufällige LED auswählen und mit dieser LED:

  if (LED[N].Jetzt - LED[N].LetzterDurchgang >= LED[N].Pause) {     // Wenn der letzte Durchgng länger her ist als die angegebene Pausen Zeit

    LED[N].PWMMin = random(0, 3);                                   // zufälliger Wert für geringste Helligkeit
    LED[N].PWMMax = random(100, 256);                               // zufälliger Wert für die höchste Helligkeit

    LED[N].DimAnfang = LED[N].Jetzt;                                // Anfang des Dimmvorgangs als jetzt definieren
    LED[N].DimDurchgang = random(LED[N].DimMin, LED[N].DimMax);     // Zufällige länge des Dimmvorgangs definieren
    LED[N].DimEnde = LED[N].DimAnfang + LED[N].DimDurchgang;        // Zeit bis zum Ende des Dimvorgangs berechnen


  if (LED[N].dunkel = true) {                                                           // Wenn die LED dunkel ist:      

      for (LED[N].Dim = LED[N].DimAnfang; LED[N].Dim > LED[N].DimEnde; LED[N].Dim++) {  // hoch dimmen
        LED[N].Helligkeit = map(LED[N].Dim, LED[N].DimAnfang, LED[N].DimEnde, 0, 255);  // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
        analogWrite(LEDs[N], LED[N].Helligkeit);                                        // Helligkeit der LED aktualisierenStatus = 1;                                                                für runterdimmen setzen
        LED[N].dunkel = false;                                                          // LED als hell definieren
      }
    }
    else {                                                                              // Wenn die LED nicht dunkel war (hell ist)
      for (LED[N].Dim = LED[N].DimEnde; LED[N].Dim > LED[N].DimAnfang; LED[N].Dim--) {  // runter dimmen
        LED[N].Helligkeit = map(LED[N].Dim, LED[N].DimAnfang, LED[N].DimEnde, 0, 255);  // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
        analogWrite(LEDs[N], LED[N].Helligkeit);                                        // Helligkeit der LED aktualisierenStatus = 1;                                                                für runterdimmen setzen
        LED[N].dunkel = true;                                                           // LED als dunkel definieren
      }
    }
    LED[N].LetzterDurchgang = millis();                                                 // Zeit für letzten Durchgang aktualisieren
    LED[N].Pause = random(LED[N].PMin, LED[N].PMax);                                    // neuer Zufallswert für die Pause generieren
  }
}

Ich werde jetzt aber schlafen gehen weil ich sonst noch verrückt werde....

Du solltest es erst mal mit einer LED und den minimalen Parametern dafür versuchen. Das kannst Du dann um weitere Parameter erweitern und dabei herausfinden, welche Parameter Du wirklich brauchst. Mir kommt das sehr übertrieben und damit äußerst unübersichtlich vor.

Wenn das funktioniert, brauchst Du nur noch die Schleifen hinzufügen.

Gruß Tommy

Tommy56:
Wenn das funktioniert, ...

... packst Du die Funktionalität in eine Methode Deiner Struktur, ergänzt noch eine Methode zur Initialisierung, und hast OOP. Wenn Du das willst und spannend findest.

Anregung könntest Du in diesem Thema finden.

ok ich versuche es noch mal... könnt ihr mir bitte vorher den Befel geben wie ich z.B. den 4ten von den 32 abgelegten Helligkeitswerten aus dem PROGMEM auslesen kann? Für euch ist es sicher eine Sekunde arbeit aber ich finde den richtigen Code einfach nirgendwo.... Dann hätte ich wenigstens das ansteuern der LED korrekt und könnte gut darauf aufbauen!

Vielen Dank im vorraus!

Ich sehe in Deinem Code kein PROGMEM-Array. Ansonsten gibt es hier einen Thread dazu.

Gruß Tommy

Danke, anhand des Beispiels habe ich es endlich verstanden!

Nun versuche ich noch mal alles Schritt für Schritt aufzubauen. Mal sehen wie weit ich komme...

Werde mich so oder so noch mal melden!

Bei PROGMEM finde ich neben der normalen Beschreibung das Arrays of strings interessant.

So, ich habe jetzt eine erste "funktionierende" Version. Was mir nicht gefällt, ist dass alles nacheinander passiert. Es kommt z.B. nie vor, dass zwei Dimmvorgänge gleichzeitig passieren. Ebenso ist der Dimmvorgang Zeitlich noch nicht richtig einstellbar glaube ich... Ich denke ich muss da noch mal umdenken und anders programieren.

Ihr könnt euch das ganze aber gerne mal ansehen und eure Meinungen und Tips dazu posten!

Ich freue mich aber sehr, dass mir bis hier hin geholfen wurde!

const uint16_t pwm[32] PROGMEM =
{
  1, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23,
  27, 32, 38, 45, 54, 64, 76, 91, 108, 128, 152, 181, 215, 255
};
//  Serial.print(pgm_read_word(&pwm[9]));


const uint8_t anzLED = 4;                // Anzahl der LED
const int Pin[4] = {3, 5, 6, 9};         // verwendete Pins (PWM) für die LEDs
char N=random(0, 4);                     // Variable für die aktive LED

struct eineLED {                         // Eigenschaften jeder LED definieren
  //Helligkeit
  boolean dunkel = true;                 // LED Status definieren (dunkel oder hell)
  int Helligkeit;                        // Variable für die LED Helligkeit
  unsigned long PWMMin = random(0, 15);  // minimale Helligkeit
  unsigned long PWMMax = random(22, 31); // maximale Helligkeit

  //uint32_t intervall;

  //Pause
  unsigned long Jetzt;                   // Variable für den aktuellen Zeitpunkt
  unsigned long Pause = 0;               // Variable: Pause zwischen den Dimmvorgängen
  const long PMin = 1000;                // kürzester Intervall
  const long PMax = 6000;                // längster Intervall
  unsigned long LetzterDurchgang = 0;    // Zeitpunkt des Letzten Dimmvorgangs

  //Dimmvorgang
  unsigned long Dim;                     // Dim Variable
  unsigned long DimAnfang;               // Dimvorgang Startzeit
  unsigned long DimDurchgang;            // Dimvorgang Gesamtdauer
  const long DimMin = 30000;             // kürzeste Dimmzeit
  const long DimMax = 60000;             // längste Dimmzeit
  unsigned long DimEnde;                 // Dimmvorgang Endzeitpunkt


};
eineLED LED[anzLED];                     // 4 Leds Generieren
void setup() {
  Serial.begin(9600);                    // Seriellen Monitor aktivieren
  randomSeed(analogRead(1));             // start der Zufallszahlen Reihenvolge durch Rauschen des Analogen Eingang 1 vorgeben
}

void loop() {
  LED[N].Jetzt = millis();               // aktuelen Zeitwert an die aktive LED in die Variale Jetzt übergeben 
  //Serial.print(LED[N].Helligkeit);
  
  if (LED[N].Jetzt - LED[N].LetzterDurchgang >= LED[N].Pause) {     // Wenn der letzte Durchgng länger her ist als die angegebene Pausen Zeit

    LED[N].DimAnfang = LED[N].Jetzt;                                // Anfang des Dimmvorgangs als jetzt definieren
    LED[N].DimDurchgang = random(LED[N].DimMin, LED[N].DimMax);     // Zufällige länge des Dimmvorgangs definieren
    LED[N].DimEnde = LED[N].DimAnfang + LED[N].DimDurchgang;        // Zeit bis zum Ende des Dimvorgangs berechnen

    if (LED[N].dunkel == true) {
      for (LED[N].Dim = LED[N].DimAnfang; LED[N].Dim < LED[N].DimEnde; LED[N].Dim++) {
        LED[N].Helligkeit = map(LED[N].Dim, LED[N].DimAnfang, LED[N].DimEnde, LED[N].PWMMin, LED[N].PWMMax);  // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
        analogWrite(Pin[N], pgm_read_word(&pwm[LED[N].Helligkeit]));
        //Serial.print(LED[N].Helligkeit);
      }
      LED[N].dunkel = false;
    }
    else {
      for (LED[N].Dim = LED[N].DimAnfang; LED[N].Dim < LED[N].DimEnde; LED[N].Dim++) {
        LED[N].Helligkeit = map(LED[N].Dim, LED[N].DimEnde, LED[N].DimAnfang, LED[N].PWMMin, LED[N].PWMMax);  // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
        analogWrite(Pin[N], pgm_read_word(&pwm[LED[N].Helligkeit]));
        //Serial.print(LED[N].Helligkeit);
      }
      LED[N].dunkel = true;
    }
    LED[N].LetzterDurchgang = millis();                                                 // Zeit für letzten Durchgang aktualisieren
    LED[N].Pause = random(LED[N].PMin, LED[N].PMax);                                    // neuer Zufallswert für die Pause generieren
    LED[N].PWMMin = random(0, 2);                                   // zufälliger Wert für geringste Helligkeit
    LED[N].PWMMax = random(29, 31);                                 // zufälliger Wert für die höchste Helligkeit
    N=random(0, 4);  
  }

}

Wenn Du in jedem Loop-Durchlauf Min und Max einr LED wieder neu per Random festlegst, wird das chaotisch. Ich würde diese Werte erst beim Erreichen der oberen (die untere neu festlegen) bzw. der unteren (dann umgekehrt).

Pro Loop Durchlauf sollte man auch alle LED bearbeiten, ob deren Zeitpunkte erreicht sind und diese dann ändern.

Gruß Tommy

Hallo Tommy!

Ich habe versucht das Umzustezen was du meinst, aber ich glaube so ist es nicht richtig...

Ich habe jetzt eine for Schleife eingefügt um sicherzustellen, dass in jedem Durchgang alle LEDs bedient werden aber dadurch ist es eher schlechter geworden.

Nun werden ert alle LEDs der Reihe nach hochgedimmt 1-4 und dann der reihe nach runtergedimmt 1-4.

Sieht natürlich nicht gut aus...

Die Max und Min Werte habe ich auch an die entsprechenden stellen verschoben denke ich:

void loop() {
  LED[N].Jetzt = millis();               // aktuelen Zeitwert an die aktive LED in die Variale Jetzt übergeben 
  //Serial.print(LED[N].Helligkeit);
  for(N=0;N<4;N++){
  
  if (LED[N].Jetzt - LED[N].LetzterDurchgang >= LED[N].Pause) {     // Wenn der letzte Durchgng länger her ist als die angegebene Pausen Zeit

    LED[N].DimAnfang = LED[N].Jetzt;                                // Anfang des Dimmvorgangs als jetzt definieren
    LED[N].DimDurchgang = random(LED[N].DimMin, LED[N].DimMax);     // Zufällige länge des Dimmvorgangs definieren
    LED[N].DimEnde = LED[N].DimAnfang + LED[N].DimDurchgang;        // Zeit bis zum Ende des Dimvorgangs berechnen

    if (LED[N].dunkel == true) {
      for (LED[N].Dim = LED[N].DimAnfang; LED[N].Dim < LED[N].DimEnde; LED[N].Dim++) {
        LED[N].Helligkeit = map(LED[N].Dim, LED[N].DimAnfang, LED[N].DimEnde, LED[N].PWMMin, LED[N].PWMMax);  // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
        analogWrite(Pin[N], pgm_read_word(&pwm[LED[N].Helligkeit]));
        //Serial.print(LED[N].Helligkeit);
      }
      LED[N].PWMMin = random(0, 2);  
      LED[N].dunkel = false;                                        // zufälliger Wert für geringste Helligkeit
    }
    else {
      for (LED[N].Dim = LED[N].DimAnfang; LED[N].Dim < LED[N].DimEnde; LED[N].Dim++) {
        LED[N].Helligkeit = map(LED[N].Dim, LED[N].DimEnde, LED[N].DimAnfang, LED[N].PWMMin, LED[N].PWMMax);  // variablen des Dimmvorgangs mappen: 0=Anfangs Intensität (zwischen 0 und 2 sowie Endintensität 255 zwischen 100 und 255)
        analogWrite(Pin[N], pgm_read_word(&pwm[LED[N].Helligkeit]));
        //Serial.print(LED[N].Helligkeit);
      }
      LED[N].PWMMax = random(29, 31);                                // zufälliger Wert für die höchste Helligkeit
      LED[N].dunkel = true;
    }
    LED[N].LetzterDurchgang = millis();                              // Zeit für letzten Durchgang aktualisieren
    LED[N].Pause = random(LED[N].PMin, LED[N].PMax);                 // neuer Zufallswert für die Pause generieren
    //N=random(0, 4);  
  }
 }
}

ich bin ja weiterhin am googeln und ich glaube dieser ganze for Kram den ich zum dimmen verwende ist mist... ich müsste das irgendwie rein über millis() und map lösen denke ich....

Da denkst Du richtig.

Gruß Tommy

berndschroed:
ich müsste das irgendwie rein über millis() ... lösen

Dazu greife ich nochmal meine Anregung aus #8 auf:

const byte pwmSchritte = 32;
const uint16_t pwm[pwmSchritte] PROGMEM =
{
  0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23,
  27, 32, 38, 45, 54, 64, 76, 91, 108, 128, 152, 181, 215, 255
};
const unsigned long PMin = 50;                    // kürzeste Dimmzeit
const unsigned long PMax = 500;                   // längste Dimmzeit

unsigned long jetzt;                     // Variable für den aktuellen Zeitpunkt

struct eineLED {
  eineLED(const byte pin): pin(pin), dunkel(true), helligkeit(0), pause(PMin), letzterDurchgang(0) {}

  void run()
  {
    if (jetzt - letzterDurchgang >= pause) {     // Wenn der letzte Durchgng länger her ist als die angegebene Pausen Zeit
      letzterDurchgang = jetzt;                                // Anfang des Dimmvorgangs als jetzt definieren

      if (dunkel) {
        analogWrite(pin, pgm_read_word(&pwm[helligkeit]));
        if (helligkeit < pwmSchritte - 1) {
          helligkeit++;
        } else {
          dunkel = !dunkel;
          pause = random(PMin, PMax);
        }
      }
      else {
        analogWrite(pin, pgm_read_word(&pwm[helligkeit]));
        if (helligkeit > 0) {
          helligkeit--;
        } else {
          dunkel = !dunkel;
          pause = random(PMin, PMax);
        }
      }
    }
  }

  const byte pin;
  bool dunkel;
  int helligkeit;                        // Variable für die LED Helligkeit
  unsigned long pause;                   // Variable: Pause zwischen den Dimmvorgängen
  unsigned long letzterDurchgang;        // Zeitpunkt des Letzten Dimmvorgangs
};

eineLED pins[] {3, 5, 6, 9};             // verwendete Pins (PWM) für die LEDs

void setup() {
  randomSeed(analogRead(1));             // start der Zufallszahlen Reihenvolge durch Rauschen des Analogen Eingang 1 vorgeben
}

void loop() {
  jetzt = millis();                      // aktuelen Zeitwert an die aktive LED in die Variale jetzt übergeben
  for (eineLED &p : pins) p.run();
}

Was Du mit dem Zufall alles machen willst, verstehe ich nicht, darum habe ich es auf eine Stelle gekürzt, damit man sieht, daß die vier LEDs tatsächlich unabhängig agieren.

Ob OOP auf einem Arduino sinnvoll ist, ist durchaus umstritten, aber bei dieser Aufgabenstellung könnte ich mich dafür begeistern.

Kurze Rückmeldung:

Ich habe Gestern nacht gegen 7 selber noch einen Sketch fertig bekommen der deinem relativ ähnlich sieht. Da ich aber z.B. die liniearen Helligkeitsschritte noch nicht integriert hatte, habe ich ihn nicht hochgeladen.

Jetzt gerade habe ich mir deinen Sketch angesehen bzw. getestet und soweit funktioniert er ebenfalls gut. Ich werde aber jetzt noch mal etwas an meinem Sketch weiter feilen weill ich den natürlich etwas besser durchschaue und schon die Pausen usw. integriert habe.

Ich möchte alles per Zufall haben damit das ganze später schön natürlich aussieht. Ich möchte so eine Art Sternenglühen realisieren. Also sehr viele kleine Lichtquellen die immer in anderen Kombinationen leuchten (Deswegen soll nicht nur die jeweilige Leuchtintensität sondern auch die Frequenz der Pausen und das Dimmen an sich variabel sein. Ich möchte keinen Blinkeffekt sondern maximal ein Pulsieren aber eben auch so langsame Fades, dass es kaum auffällt, dass sich etwas verändert.

Wie gesagt vielen Dank für eure Unterstützung und auch deinen Letzten Vorschlag. Das mit OOP wäre momentan glaube ich zu heftig für mich. Ich bin jetzt so schon am absoluten Limit gelaufen. Wie gesagt ich kann garkeine Programiersprache. Ich lese immer nur den Code und versuche zu verstehen was dahinter steckt, damit ich mir die benötigten Sachen zusammen basteln kann...

Sobald ich halbwegs zufrieden bin poste ich noch mal meinen Code! Ggf. habe ich dann auch noch Fragen dazu. Warten wir mal ab :slight_smile: