Steuerung LED Dimmung für Aqua

Soweit verstanden. Aber selbst dann befinde ich mich doch immer noch in der "for" schleife bis die bei dem Zielwert für i gelandet ist?
Oder umgeh ich das? Muss mir mal das andere Beispiel anschauen-

Eine for-Schleife entfällt dabei völlig, an deren Stelle tritt nun ein if-Anweisung:

wenn verstricheneZeirt > 2500 dann PWMWert=PWMWert+1

Das ganze bis zum PWMWert 255.

Hallo und Danke,
macht Sinn und hört sich auch einfach umzusetzen an. Werd mich damit mal die Tage befassen.

Generell noch mal eine Frage:
Wenn ich im Loop eine Funktion aufrufe mit "funktion();" wie kann ich dann Parameter mit übergeben? Kann ich die nicht in den Klammern mit übergeben? Dafür dachte ich sind die gedacht.

Aktuell mach ich das ja so:
a=1;
b=5;
c=17;
funktion();

Übersichtlicher und einfacher wäre es doch, wenn ich einfach nur
funktion(1, 5, 17);
aufrufen könnte?

Wo beschreibe ich denn dann, welcher Wert in der Klammer an welchem Parameter übergeben wird? Bzw. geht das überhaupt?

Gruß

Ja, man kann auch Werte übergeben, um es kurz zu machen, verweise ich mal auf diesen Thread:
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1294352148

Hallo,
hab mich direkt mal rangemacht. Die Parallelschaltung mittles if-Befehle habe ich hinbekommen:

//////////WICHTIGE SETUP-DATEN FÜR REALTIME UHRZEIT//////////////////
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}
//////////ENDE WICHTIGE DATEN FÜR REALTIME UHRZEIT////////////////


//////////WICHTIGE SETUP-DATEN FÜR LEDs//////////////////
byte stripePin[] = {8, 9, 10, 11};
int i=0;
int ii=255;
int j=0;
int jj=255;
int k=0;
int kk=255;
int l=0;
int ll=255;
long bluemillis;
long whitemillis;
long redmillis;
long uvmillis;
byte intervalli;
byte intervallj;
byte intervallk;
byte intervalll;
byte intervallii;
byte intervalljj;
byte intervallkk;
byte intervallll;
//////////ENDE WICHTIGE SETUP-DATEN FÜR LEDs//////////////////



//////////FUNKTION FÜR UHRZEIT//////////////////
void setDateDs1307(byte second,        // 0-59
                   byte minute,        // 0-59
                   byte hour,          // 1-23
                   byte dayOfWeek,     // 1-7
                   byte dayOfMonth,    // 1-28/29/30/31
                   byte month,         // 1-12
                   byte year)          // 0-99
{
   Wire.beginTransmission(DS1307_I2C_ADDRESS);
   Wire.send(0);
   Wire.send(decToBcd(second));    // 0 to bit 7 starts the clock
   Wire.send(decToBcd(minute));
   Wire.send(decToBcd(hour));      // If you want 12 hour am/pm you need to set
                                   // bit 6 (also need to change readDateDs1307)
   Wire.send(decToBcd(dayOfWeek));
   Wire.send(decToBcd(dayOfMonth));
   Wire.send(decToBcd(month));
   Wire.send(decToBcd(year));
   Wire.endTransmission();
}
void getDateDs1307(byte *second,
          byte *minute,
          byte *hour,
          byte *dayOfWeek,
          byte *dayOfMonth,
          byte *month,
          byte *year)
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.endTransmission();
  
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  *second     = bcdToDec(Wire.receive() & 0x7f);
  *minute     = bcdToDec(Wire.receive());
  *hour       = bcdToDec(Wire.receive() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month      = bcdToDec(Wire.receive());
  *year       = bcdToDec(Wire.receive());
}
//////////ENDE FUNKTION FÜR UHRZEIT//////////////////


void setup()
{
  /////////////UHRZEIT////////////////// ZUM UHRZEIT STELLEN EINTRAGEN UND SETDATE FÜR UPLOAD AKTIVIEREN//////
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
 Serial.begin(9600);
//    minute = 46;
//    hour = 23;
//    dayOfWeek = 6;
//    dayOfMonth = 5;
//    month = 2;
//    year = 10;
//    setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
  //////////////UHRZEIT ENDE//////////////
  
   /////////////LEDs//////////////////
   pinMode(stripePin[0], OUTPUT);
   digitalWrite(stripePin[0], LOW);
   pinMode(stripePin[1], OUTPUT);
   digitalWrite(stripePin[1], LOW);
   pinMode(stripePin[2], OUTPUT);
   digitalWrite(stripePin[2], LOW);
   pinMode(stripePin[3], OUTPUT);
   digitalWrite(stripePin[3], LOW);
 
   /////////////ENDE LEDs//////////////////
}

void loop()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

//LED Stripe 1 - Blau//
  if (minute == 30 && hour == 7 && second == 00) {
            bluemillis=millis();
            i=1;
            intervalli = 90*60000/256;
            analogWrite(stripePin[0], i);
  }
  if (i>0 && millis() - bluemillis > intervalli) {
            bluemillis = millis();
            if (i<255){
            analogWrite(stripePin[0], i++);
            }
            if (i=255){
            digitalWrite(stripePin[0], HIGH);
            }
  }
  if (minute == 00 && hour == 20 && second == 00) {
            bluemillis=millis();
            ii=254;
            intervallii = 90*60000/256;
            analogWrite(stripePin[0], ii);
  }
  if (ii<255 && millis() - bluemillis > intervallii) {
            bluemillis = millis();
            if (ii>0){
            analogWrite(stripePin[0], ii--);
            }
            if (ii=0){
            digitalWrite(stripePin[0], LOW);
            }
  }
//LED Stripe 2 - Weiss//  
  if (minute == 00 && hour == 8 && second == 00) {
            whitemillis=millis();
            j=1;
            intervallj = 120*60000/256;
            analogWrite(stripePin[1], j);
  }
  if (j>0 && millis() - whitemillis > intervallj) {
            whitemillis = millis();
            if (j<255){
              analogWrite(stripePin[1], j++);
            }
  }      
//LED Stripe 3 - Weiss + Rot// 
  if (minute == 30 && hour == 10 && second == 00) {
            redmillis=millis();
            k=1;
            intervallk = 90*60000/256;
            analogWrite(stripePin[2], k);
  }
  if (k>0 && millis() - redmillis > intervallk) {
            redmillis = millis();
            if (k<255){
            analogWrite(stripePin[2], k++);
            }
  }    
//LED Stripe 4 - Blau + UV// 
  if (minute == 00 && hour == 11 && second == 00) {
            redmillis=millis();
            l=1;
            intervalll = 60*60000/256;
            analogWrite(stripePin[3], l);
  }
  if (l>0 && millis() - redmillis > intervalll) {
            redmillis = millis();
            if (l<255){
            analogWrite(stripePin[3], l++);
            }
  }    
//Ausgabe Uhrzeit//   
  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  Serial.print(hour, DEC);
  Serial.print(":");
  Serial.print(minute, DEC);
  Serial.print(":");
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(month, DEC);
  Serial.print("/");
  Serial.print(dayOfMonth, DEC);
  Serial.print("/");
  Serial.print(year, DEC);
  Serial.print("  Day_of_week:");
  Serial.println(dayOfWeek, DEC);
  delay(1000);
 }

Was mich jetzt allerdings noch stört (eben wegen der Übersichtlichkeit) ist, dass ich für alle 4 LED-Ketten und dann jeweils für FadeIn & FadeOut eigene Variablen anlegen muss. Sprich LED1 FadeIn wird mit i aufgedreht, LED1 FadeOut wird mit ii runtergedreht.
Wenn ich für beide die Variable i nehmen würde, würden irgendwann die Befehlsketten durcheinander laufen.

Gibt es da Tipps von euch?

Viele Grüße
Thorsten

Ja:

int i=0;
int a=0;

...

//LED Stripe 1 - Blau//
  if (minute == 30 && hour == 7 && second == 00) {
            bluemillis=millis();
            a=1;
            intervalli = 90*60000/256;
  }
  else if (minute == 00 && hour == 20 && second == 00) {
            bluemillis=millis();
            a=-1;
            intervallii = 90*60000/256;
  }
  if (a!=0 && millis() - bluemillis > intervalli) {
            bluemillis = millis();
            i+=a;
            switch(i) {
                case 0:
                    digitalWrite(stripePin[0], LOW);
                    a=0;
                    break;
                case 255:
                    digitalWrite(stripePin[0], HIGH);
                    a=0;
                    break;
                default:
                    analogWrite(stripePin[0], i);
            }
  }

Wow, vielen Dank.
Sieht super aus, werd ich heut Abend doch mal direkt testen.
Heißt aber für die unterschiedlichen LED-stripes muss ich insgesamt schon unterschiedliche Variablen nutzen richtig?
Macht es Sinn hier mit Arrays zu arbeiten?

So langsam wirds 8)
Dann kann ich mich ja bald schon an die AUsgabe über meinen LCD ranmachen, das wird auch noch mal nen Akt (zumindest für mich ]:smiley: )

Gruß
Thorsten

Arrays machen in diesem Fall sogar sehr viel Sinn und sparen eine menge Code.
Sollte so funktionieren (ungetestet):

//////////WICHTIGE SETUP-DATEN FÜR REALTIME UHRZEIT//////////////////
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}
//////////ENDE WICHTIGE DATEN FÜR REALTIME UHRZEIT////////////////


//////////WICHTIGE SETUP-DATEN FÜR LEDs//////////////////
#define MAX_STRIPES 4
byte stripePin[] = {8, 9, 10, 11};
int i[] = {0, 0, 0, 0};
int a[] = {0, 0, 0, 0};
long currmillis[4];
byte intervall[] = {90*60000/256, 120*60000/256, 90*60000/256, 60*60000/256};
byte hourfadein[] = {7, 8, 10, 11};
byte hourfadeout[] = {20, 100, 100, 100};   // if hour=100, stripe doesn't fade out
byte minutefadein[] = {30, 0, 30, 0};
byte minutefadeout[] = {0, 0, 0, 0};
//////////ENDE WICHTIGE SETUP-DATEN FÜR LEDs//////////////////



//////////FUNKTION FÜR UHRZEIT//////////////////
void setDateDs1307(byte second,        // 0-59
                   byte minute,        // 0-59
                   byte hour,          // 1-23
                   byte dayOfWeek,     // 1-7
                   byte dayOfMonth,    // 1-28/29/30/31
                   byte month,         // 1-12
                   byte year)          // 0-99
{
   Wire.beginTransmission(DS1307_I2C_ADDRESS);
   Wire.send(0);
   Wire.send(decToBcd(second));    // 0 to bit 7 starts the clock
   Wire.send(decToBcd(minute));
   Wire.send(decToBcd(hour));      // If you want 12 hour am/pm you need to set
                                   // bit 6 (also need to change readDateDs1307)
   Wire.send(decToBcd(dayOfWeek));
   Wire.send(decToBcd(dayOfMonth));
   Wire.send(decToBcd(month));
   Wire.send(decToBcd(year));
   Wire.endTransmission();
}
void getDateDs1307(byte *second,
          byte *minute,
          byte *hour,
          byte *dayOfWeek,
          byte *dayOfMonth,
          byte *month,
          byte *year)
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  *second     = bcdToDec(Wire.receive() & 0x7f);
  *minute     = bcdToDec(Wire.receive());
  *hour       = bcdToDec(Wire.receive() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month      = bcdToDec(Wire.receive());
  *year       = bcdToDec(Wire.receive());
}
//////////ENDE FUNKTION FÜR UHRZEIT//////////////////


void setup()
{
  /////////////UHRZEIT////////////////// ZUM UHRZEIT STELLEN EINTRAGEN UND SETDATE FÜR UPLOAD AKTIVIEREN//////
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
 Serial.begin(9600);
//    minute = 46;
//    hour = 23;
//    dayOfWeek = 6;
//    dayOfMonth = 5;
//    month = 2;
//    year = 10;
//    setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
  //////////////UHRZEIT ENDE//////////////

   /////////////LEDs//////////////////
   pinMode(stripePin[0], OUTPUT);
   digitalWrite(stripePin[0], LOW);
   pinMode(stripePin[1], OUTPUT);
   digitalWrite(stripePin[1], LOW);
   pinMode(stripePin[2], OUTPUT);
   digitalWrite(stripePin[2], LOW);
   pinMode(stripePin[3], OUTPUT);
   digitalWrite(stripePin[3], LOW);

   /////////////ENDE LEDs//////////////////
}

void loop()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;


  for (int loop=0; loop<MAX_STRIPES; loop++) {
            if (minute == minutefadein[loop] && hour == hourfadein[loop] && second == 0) {
                      currmillis[loop]=millis();
                      a[loop]=1;
            }
            else if (minute == minutefadeout[loop] && hour == hourfadeout[loop] && second == 0) {
                      currmillis[loop]=millis();
                      a[loop]=-1;
            }
            if (a[loop]!=0 && millis() - currmillis[loop] > intervall[loop]) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      switch(i[loop]) {
                          case 0:
                              digitalWrite(stripePin[loop], LOW);
                              a[loop]=0;
                              break;
                          case 255:
                              digitalWrite(stripePin[loop], HIGH);
                              a[loop]=0;
                              break;
                          default:
                              analogWrite(stripePin[loop], i[loop]);
                      }
            }
  }


//Ausgabe Uhrzeit//
  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  Serial.print(hour, DEC);
  Serial.print(":");
  Serial.print(minute, DEC);
  Serial.print(":");
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(month, DEC);
  Serial.print("/");
  Serial.print(dayOfMonth, DEC);
  Serial.print("/");
  Serial.print(year, DEC);
  Serial.print("  Day_of_week:");
  Serial.println(dayOfWeek, DEC);
  delay(1000);
 }

Hi,
weiss ja jetzt, an wen ich mich wenden muss für die weitere Programmierung ]:smiley: Vielen Dank. Sieht sehr vielversprechend aus und bin gespannt, obs direkt funktioniert!
Wird mir auf jeden Fall einiges erleichtern.

Gruß
Thorsten

Hallo,
zwei Fragen, leider hatte ich heute keine Zeit, den code am arduino zu testen, daher bin ich das ganze nur mal im Kopf durchgegangen, will ja auch verstehen was passiert:

  1. MAX_STRIPES wird mit =4 definiert, durchläuft dann die for schleife nicht 5 mal das Ganze? (0,1,2,3,und 4 da ja: solange <4, bitte mach +1) Oder heisst #define 4, dass der höchste Wert=3 ist, da bei 0 begonnen wird?

  2. was passiert, wenn in der for schleife loop=MAX_STRIPES erreicht wird? Stoppt sie dann oder fängt sie immer wieder von vorne an? Ich möchte ja erreichen, dass die fadeins und fadeouts jeden tag von neuem starten.

Gruß
Thorsten

zu 1) maxstripes ist 4, die Schleife wird solange aufgeführt, wie der Zähler kleiner 4 ist, und damit 0, 1, 2, 3.
zu 2) Tja, was passiert wohl nach dieser Schleife? Sie ist zu Ende, danach erfolgt in MaFus Code die Ausgabe. Und danach gehts wieder neu los, schließlich sind wir ja gerade in der loop ().

hi und danke,
hab das grad auch noch mal durchlaufen und gecheckt, hätt mir die Frage also sparen können. War nen denkfehler :zipper_mouth_face:
aber eines muss ich doch noch mal fragen, auch wenns dir logisch erscheint:
was passiert hier?
i[loop]+=a[loop];
=> wird aus i=i+a?
das hieße ja im else-fall (a=-1) dass i=0-1 wird??
Wäre ja unlogisch, aber ich finde im netz grad keine definition von +=
(hier steht der leider nicht: http://www.arduino-tutorial.de/2010/06/operatoren/ )

Gruß und danke schon mal

EDIT//
rein logisch müsste das doch bedeuten:
i=i+(1*a)

was passiert hier?
i[loop]+=a[loop];
=> wird aus i=i+a?
das hieße ja im else-fall (a=-1) dass i=0-1 wird??
Wäre ja unlogisch, aber ich finde im netz grad keine definition von +=
(hier steht der leider nicht: http://www.arduino-tutorial.de/2010/06/operatoren/ )

Gruß und danke schon mal

EDIT//
rein logisch müsste das doch bedeuten:
i=i+(1*a)

i+=a ist einfach nur die C typische Abkürzung für i=i+a.
genau so gibt es auch -=, =, /, &=, |=, usw.
i++ ist ja auch nur die Kurzform von i=i+1

Übrigens ist Dein Einwand berechtigt, da fehlt noch was:
anstelle

a[loop]=1;

gehört da ein

i[loop]=0;
a[loop]=1;

und anstelle von

a[loop]=-1;

gehört

i[loop]=255;
a[loop]=-1;

Dann wird beim hochzählen bei 0 und beim runterzählen bei 255 begonnen.

Hi,
super, bins im Kopf gerad mal durchgegangen und macht Sinn!
Bin gespannt aufs testen
Gruß

Hallo,
läuft alles perfekt - hab das Ding bereits in BEtrieb.
Kann natürlich nicht so bleiben, ein paar Erweiterungen hätte ich da noch im Kopf:

  1. zur Mittagszeit würde ich gerne auf alle Stripes eine Zufallssteuerung einbauen, d.h. von ca 12-14 sollen die Werte random(256) annehmen und dann wieder zurück auf 255/HIGH
    => Hab da schon mit angefangen, code gerade nicht zur Hand. Aber insbesondere mit der random FUnktion tu ich mich noch schwer, da durch dir If-klausel der Random ja jedes mal wieder neu berechnet wird.

  2. gerne würde ich über serial. auch mal die Werte anpassen, d.h. ich schicke für stripe1 den Wert 100, dann soll automatisch in einer vordefinierten Zeit (zB i++ alle 10 Sekunden) hoch oder runter gefaded werden, je nachdem wo der Stripe gerade ist. Generell ist das sicherlich nicht schwer, aber ich bin mir noch nicht sicher, wie ich das integriere, ohne die eigentliche Steuerung zu verwirren. (Sprich wenn er abends runter dimmt, ich dann aber noch mal eine Farbe hochdimmen möchte, soll er natürlich nicht danach wieder automatisch runterdimmen.)

Alles noch recht komplex, aber vielleicht habt ihr ja shcon mal ein paar Ideen/ansätze auf die ich aufbauen kann.
Ich denke mit der Zufallssteuerung würde ich starten wollen, das ist vermutlich doch einfacher für den Anfang.

Grüße
Thorsten

EDIT//
zu 2: das werde ich wohl am besten über 4 potentiometer lösen. Was denkt ihr?

anbei mal mein Code.
An die Potisteuerung bin ich noch nicht ran, Änderung ist lediglich dass ich versucht habe, eine Zufallssteuerung einzubauen. Diese läuft Mittags zwischen 13 und 14h15 und betrifft alle Kanäle.

  1. Habe das Array auf 5 erweitert. Kann ich nur für die Zufallssteuerung einfach die 5te Variable weglassen? Weil hier will ich nur die 4 HauptLEDs ansprechen, nicht das Mondlicht.

  2. Bzgl. der Zufallsteuerung, schaut euch das bitte mal an. Zum einen habe ich die Variable check eingefügt, mittels der ich trenne, ob es sich um 0/255 oder um einen random wert handelt. und das ist nur in einer elseif schleife so. Ist das umständlich?

  3. Muss ich den Wert i[loop] überhaupt speichern (store)? Wichtig ist, wenn zufall = 133 ist, dass in der späteren if schleife "noonminutefadein[loop]" ab dem jeweiligen random wert wieder hochgefaded wird bis 255.

Bin gespannt was ihr sagt.
Habe leider noch nicht live getestet, nur gerade mal so hinprogrammiert.

Gruß

//////////WICHTIGE SETUP-DATEN FÜR REALTIME UHRZEIT//////////////////
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}
//////////ENDE WICHTIGE DATEN FÜR REALTIME UHRZEIT////////////////


//////////WICHTIGE SETUP-DATEN FÜR LEDs//////////////////
#define MAX_STRIPES 5
byte stripePin[] = {8, 9, 10, 11, 12}; //8=weiss 9=blau 10=blau+UV 11=weiss+rot, 12=moon
int i[] = {0, 0, 0, 0, 0};
int a[] = {0, 0, 0, 0, 0}; 
int check[] = {0, 0, 0, 0, 0};
long currmillis[5];
long timemillis = 0;
float intervall[5];
float intervallfadein[] = {90*60000/256, 60*60000/256, 120*60000/256, 90*60000/256, 30*60000/256};
float intervallnoon[] = {10*60000/256, 10*60000/256, 10*60000/256, 10*60000/256, 10*60000/256};
float intervallfadeout[] = {60*60000/256, 90*60000/256, 90*60000/256, 90*60000/256, 30*60000/256}; //jeweils erste Zahl = Fadingdauer im Minuten
byte hourfadein[] = {8, 8, 10, 10, 20};
byte noonhourfadeout[] = {13, 13, 13, 13, 13};
byte noonhourfadein[] = {14, 14, 14, 14, 14};
byte hourfadeout[] = {19, 19, 17, 17, 8};   
byte minutefadein[] = {0, 0, 30, 30, 30};
byte noonminutefadeout[] = {0, 0, 0, 0, 0};
byte noonminutefadein[] = {15, 15, 15, 15, 15};
byte minutefadeout[] = {0, 30, 0, 0, 0};
int zufall[5];
int store[5];
//////////ENDE WICHTIGE SETUP-DATEN FÜR LEDs//////////////////



//////////FUNKTION FÜR UHRZEIT//////////////////
void setDateDs1307(byte second,        // 0-59
                   byte minute,        // 0-59
                   byte hour,          // 1-23
                   byte dayOfWeek,     // 1-7
                   byte dayOfMonth,    // 1-28/29/30/31
                   byte month,         // 1-12
                   byte year)          // 0-99
{
   Wire.beginTransmission(DS1307_I2C_ADDRESS);
   Wire.send(0);
   Wire.send(decToBcd(second));    // 0 to bit 7 starts the clock
   Wire.send(decToBcd(minute));
   Wire.send(decToBcd(hour));     
   Wire.send(decToBcd(dayOfWeek));
   Wire.send(decToBcd(dayOfMonth));
   Wire.send(decToBcd(month));
   Wire.send(decToBcd(year));
   Wire.endTransmission();
}
void getDateDs1307(byte *second,
          byte *minute,
          byte *hour,
          byte *dayOfWeek,
          byte *dayOfMonth,
          byte *month,
          byte *year)
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  *second     = bcdToDec(Wire.receive() & 0x7f);
  *minute     = bcdToDec(Wire.receive());
  *hour       = bcdToDec(Wire.receive() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month      = bcdToDec(Wire.receive());
  *year       = bcdToDec(Wire.receive());
}
//////////ENDE FUNKTION FÜR UHRZEIT//////////////////


void setup()
{
  /////////////UHRZEIT////////////////// ZUM UHRZEIT STELLEN EINTRAGEN UND SETDATE FÜR UPLOAD AKTIVIEREN//////
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
 Serial.begin(9600);
//    minute = 46;
//    hour = 23;
//    dayOfWeek = 6;
//    dayOfMonth = 5;
//    month = 2;
//    year = 10;
//    setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
  //////////////UHRZEIT ENDE//////////////

   /////////////LEDs//////////////////
   pinMode(stripePin[0], OUTPUT);
   digitalWrite(stripePin[0], LOW);
   pinMode(stripePin[1], OUTPUT);
   digitalWrite(stripePin[1], LOW);
   pinMode(stripePin[2], OUTPUT);
   digitalWrite(stripePin[2], LOW);
   pinMode(stripePin[3], OUTPUT);
   digitalWrite(stripePin[3], LOW);
   pinMode(stripePin[4], OUTPUT);
   digitalWrite(stripePin[4], LOW);

   /////////////ENDE LEDs//////////////////
}

void loop()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;


  for (int loop=0; loop<MAX_STRIPES; loop++) {
            if (minute == minutefadein[loop] && hour == hourfadein[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=0;
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallfadein[loop];
            }
             else if (minute == noonminutefadeout[loop] && hour == noonhourfadeout[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=2;
                      zufall[loop]=random(256);
                      intervall[loop]=intervallnoon[loop];
            }
             else if (minute == noonminutefadein[loop] && hour == noonhourfadein[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=store[loop];
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallnoon[loop];
            }    
            else if (minute == minutefadeout[loop] && hour == hourfadeout[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=1;
                      intervall[loop]=intervallfadeout[loop];
            }
             if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 1) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      switch(i[loop]) {
                          case 0:
                              digitalWrite(stripePin[loop], LOW);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          case 255:
                              digitalWrite(stripePin[loop], HIGH);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          default:
                              analogWrite(stripePin[loop], i[loop]);
                      }
            }
            else if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 2) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      if (i[loop]>zufall[loop]) {
                          analogWrite(stripePin[loop], i[loop]);
                      }
                      else {
                        store[loop]=i[loop];
                        a[loop]=0;
                        
                      }
            }
  }


//Ausgabe Uhrzeit//
if (millis() - timemillis > 1000) {
  timemillis = millis();
  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  Serial.print(hour, DEC);
  Serial.print(":");
  Serial.print(minute, DEC);
  Serial.print(":");
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(dayOfMonth, DEC);
  Serial.print(".");  
  Serial.print(month, DEC);
  Serial.print(".");
  Serial.print(year, DEC);
  Serial.print("  Tag:");
  Serial.println(dayOfWeek, DEC);
  }
 }

Hallo,
ich brauche doch mal dringend eure Hilfe:
Habe den code (siehe letzter Beitrag) noch einmal angepasst, da ich auf meinem ErsatzArduino keine RTC habe. Daher dachte ich mir, dass ich das ja auch so testen kann, in dem ich statt eine Uhrzeit einfach angebe, nach welcher Ablaufzeit ( millis()) der jeweilige Fade starten soll. Gesagt getan, 4 normale LEDs angeschlossen....direkt nach Upload sind alle 4 LEDs direkt an, anstatt nacheinander einzufaden.

Verstehe ich jetzt nicht, finde den Fehler leider nicht...hoffe jemand kann helfen :astonished:

//////////WICHTIGE SETUP-DATEN FÜR LEDs//////////////////
#define MAX_STRIPES 5
byte stripePin[] = {8, 9, 10, 11, 12}; //8=weiss 9=blau 10=blau+UV 11=weiss+rot, 12=moon
int i[] = {0, 0, 0, 0, 0};
int a[] = {0, 0, 0, 0, 0}; 
int check[] = {0, 0, 0, 0, 0};
long currmillis[5];
long timemillis = 0;
float intervall[5];
float intervallfadein[] = {1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256};
float intervallnoon[] = {1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256};
float intervallfadeout[] = {1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256}; //jeweils erste Zahl = Fadingdauer im Minuten
byte hourfadein[] = {2000, 2500, 3000, 4000, 5000};
byte noonhourfadeout[] = {15000, 15000, 15000, 15000, 15000};
byte noonhourfadein[] = {25000, 25000, 25000, 25000, 25000};
byte hourfadeout[] = {40000, 42000, 44000, 46000, 48000};   
int zufall[5];
int store[5];
//////////ENDE WICHTIGE SETUP-DATEN FÜR LEDs//////////////////

void setup()
{
 

   /////////////LEDs//////////////////
   pinMode(stripePin[0], OUTPUT);
   digitalWrite(stripePin[0], LOW);
   pinMode(stripePin[1], OUTPUT);
   digitalWrite(stripePin[1], LOW);
   pinMode(stripePin[2], OUTPUT);
   digitalWrite(stripePin[2], LOW);
   pinMode(stripePin[3], OUTPUT);
   digitalWrite(stripePin[3], LOW);
   pinMode(stripePin[4], OUTPUT);
   digitalWrite(stripePin[4], LOW);

   /////////////ENDE LEDs//////////////////
}

void loop()
{



  for (int loop=0; loop<MAX_STRIPES; loop++) {
            if (millis() == hourfadein[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=0;
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallfadein[loop];
            }
             else if (millis() == noonhourfadeout[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=2;
                      zufall[loop]=random(256);
                      intervall[loop]=intervallnoon[loop];
            }
             else if (millis() == noonhourfadein[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=store[loop];
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallnoon[loop];
            }    
            else if (millis() == hourfadeout[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=1;
                      intervall[loop]=intervallfadeout[loop];
            }
             if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 1) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      switch(i[loop]) {
                          case 0:
                              digitalWrite(stripePin[loop], LOW);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          case 255:
                              digitalWrite(stripePin[loop], HIGH);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          default:
                              analogWrite(stripePin[loop], i[loop]);
                      }
            }
             else if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 2) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      if (i[loop]>zufall[loop]) {
                          analogWrite(stripePin[loop], i[loop]);
                      }
                      else {
                        store[loop]=i[loop];
                        a[loop]=0;
                        
                      }
             }
  }



 }

Keiner da, der mir helfen kann/will?
Hab noch einige Zeit rumgefriemelt, will den Fehler aber nicht finden.

EIne Überlegung, die ich hatte: da ich ja mit millis() arbeite, sage ich dem Arduino, dass er GENAU dann, wenn millis() einen bestimmten Wert hat, eine FUnktion ausführen soll. KAnn es sein, dass das nicht geht, da zu wenig TOleranz? Ich stelle mir das so vor, dass die Schleife nicht immer genau bei 2000 ms an der if-ABfrage ist, sondern vielleicht bei 2013ms oder so. Könnte das sein?
Gruß