Steuerung LED Dimmung für Aqua

Hi,
ich möchte über PWM meine LEDs steuern. Sind insgesamt 4 Stripes.
Wie ihr meinem Script ansehen werdet, bin ich noch kein Profi, damit würde ich aber zumindest eine zeitgesteuerte Dimmung hinbekommen.
Ideal finde ich es allerdings noch nicht. Zum einen würde ich gerne auch LEDs parallel dimmen, zum anderen auch die Zeitausgabe (demnächst über LCD) regelmäßig aktualisieren. Außerdem sollen noch weitere Sensoren mit integriert werden, die ja auch in geregelten Abständen geprüft werden müssen.

So wie ich es jetzt programmier habe, geht quasi ab 7Uhr30 die Sonne auf. Mittags wird sie mit voller Kraft scheinen.
Das Problem ist, dass wenn zB um 7h30 der erste LED Strip startet, der Loop so lange durchläuft,bis max=155 erreicht ist, dauer beträgt dabei 45 Minuten. D.h. während dieser Zeit wird natürlich weder die Zeit aktualisiert, noch könnte ich eine 2te LED starten.

Könnt ihr mir hier helfen?
Gruß
Thorsten

//////////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 currentStripe = 0;
int dauer=0;   //Dauer in Minuten
int i;
int imax;
int imin;
float delayfade=dauer*60000/256;
//////////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;
//FADEIN//
  if (minute == 30 && hour == 7 && second == 0) {
            currentStripe=1; //blau
            int dauer=45;   //Dauer in Minuten
            i=0;
            imax=155;
            FadeIn();
            }
  if (minute == 30 && hour == 8 && second == 0) {
            currentStripe=2;  //weiss
            int dauer=45;   //Dauer in Minuten
            i=0;
            imax=155;
            FadeIn();
            }
   if (minute == 20 && hour == 9 && second == 0) {
            currentStripe=1; //blau
            int dauer=30;   //Dauer in Minuten
            i=155;
            imax=255;
            FadeIn();
            digitalWrite(stripePin[currentStripe], HIGH);
            }
  if (minute == 55 && hour == 9 && second == 0) {
            currentStripe=2;  //weiss
            int dauer=30;   //Dauer in Minuten
            i=155;
            imax=255;
            FadeIn();
            digitalWrite(stripePin[currentStripe], HIGH);
            }           
            
  if (minute == 00 && hour == 10 && second == 0) {
            currentStripe=3; // weiss&rot
            int dauer=59;   //Dauer in Minuten
            i=0;
            imax=155;
            FadeIn();
            }
  if (minute == 00 && hour == 11 && second == 0) {
            currentStripe=4; //blau und UV 
            int dauer=59;   //Dauer in Minuten
            i=0;
            imax=155;
            FadeIn();
            }
   if (minute == 00 && hour == 12 && second == 0) {
            currentStripe=3; // weiss&rot
            int dauer=29;   //Dauer in Minuten
            i=155;
            imax=255;
            FadeIn();
            digitalWrite(stripePin[currentStripe], HIGH);
            }
  if (minute == 30 && hour == 12 && second == 0) {
            currentStripe=4; //blau und UV 
            int dauer=29;   //Dauer in Minuten
            i=155;
            imax=255;
            FadeIn();
            digitalWrite(stripePin[currentStripe], HIGH);
            }           
//FADE OUT// 
  if (minute == 00 && hour == 16 && second == 0) {
            currentStripe=3;
            int dauer=29;   //Dauer in Minuten
            i=255;
            imin=100;
            FadeOut();
            }
   if (minute == 30 && hour == 16 && second == 0) {
            currentStripe=4;
            int dauer=29;   //Dauer in Minuten
            i=255;
            imin=100;
            FadeOut();
            } 
   if (minute == 00 && hour == 17 && second == 0) {
            currentStripe=3;
            int dauer=29;   //Dauer in Minuten
            i=100;
            imin=0;
            FadeOut();
            digitalWrite(stripePin[currentStripe], LOW);
            } 
   if (minute == 30 && hour == 17 && second == 0) {
            currentStripe=4;
            int dauer=29;   //Dauer in Minuten
            i=100;
            imin=0;
            FadeOut();
            digitalWrite(stripePin[currentStripe], LOW);
            } 
   if (minute == 00 && hour == 19 && second == 0) {
            currentStripe=2; //weiss
            int dauer=29;   //Dauer in Minuten
            i=255;
            imin=100;
            FadeOut();
            } 
   if (minute == 30 && hour == 19 && second == 0) {
            currentStripe=1; //blau
            int dauer=29;   //Dauer in Minuten
            i=255;
            imin=155;
            FadeOut();
            }             
   if (minute == 00 && hour == 19 && second == 0) {
            currentStripe=2; //weiss
            int dauer=29;   //Dauer in Minuten
            i=100;
            imin=0;
            FadeOut();
            digitalWrite(stripePin[currentStripe], LOW);
            } 
   if (minute == 30 && hour == 19 && second == 0) {
            currentStripe=1; //blau
            int dauer=29;   //Dauer in Minuten
            i=155;
            imin=0;
            FadeOut();
            digitalWrite(stripePin[currentStripe], LOW);         
            }                  
  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);
 }
 
void FadeIn()
{
 for(i; i<imax; i++) {
   analogWrite(stripePin[currentStripe], i);
   delay(delayfade);
 }
}

void FadeOut()
{
 for(i; i>imin; i--) {
   analogWrite(stripePin[currentStripe], i);
   delay(delayfade);
 }
}

Hallo currymuetze,

das sieht ja toll aus.

mmh, ich finde es toll wie du den Code aufgeteilt hast, glaube aber das das Problem genau hier liegt.

Du springst aus dem Loop in die Unterfunktion FadeIN und arbeitest den Fade in einer For Schleife ab,
... und Du hast recht, jetzt wird es etwas schwierig mit relatime LCD und anderen Leds.

Das Stichwort lautet wohl Interrupts. Alternativ könntest Du überlegen ob du das Faden nicht in direkte abhängigkeit von der Uhrzeit umsetzt.
(Innerhalb des Loops...)

Ich habe da im deutschsprachigen Playground zum Interrupt mal ein beispiel eingestellt... schon lange her... und sicher gehts besser,
aber damals habe ich mich mit einer sehr ähnlichen Thematik befasst. Das könntest Du Dir mal anschauen. Ging um Interrupts in Abhängigkeit zur Timer-Library.

Du mußt wenn Du mehr Leds schalten oder LCD Ausgaben machen willst die Schleife so oder so "verlassen" oder mit den zusätzlichen Funktionen mischen.
Interrupts sind da eine gute Möglichkeit, indem Du per Interrupt
den LCD Ausgaben, (Led Möglichkeiten) quasi eine höhere Priorität zuweist.

Natürlich könntest Du auch innerhalb des FadeIN's deine LCD Ausgabe machen, denke aber dann wird es vielleicht etwas unübersichtlich.

Du könntest Dir auch einen Trigger basteln. Wenn +1 Minute dann....

Das ganze soll jetzt erstmal nur eine Inspiration sein, deine strukturierte Programmierweise... HUTAB! Müsstest aber dennoch vielleicht konzeptionell
etwas ändern.

Ich wünsche Dir viel Erfolg, der Ansatz ist sauber, und ich bin gespannt auf die Präsentation im Exhibitionbereich! :slight_smile:

Lieber Gruß
ChrisS

Hi Chris,

vielen Dank für dein Feedback.
Dass ich noch einiges konzeptionell verbessern muss ist richtig. Funktionieren tut es so, komfortabel isses nicht wirklich.
Insbesondere der Aufruf jeder einzelnen Dimmung ist noch umständlich, da stell ich mir eher vor, dass ich den Aufruf deutlich vereinfache (z.B. fadeIn(LED1, 7:30, 30%)) hab allerdings noch nicht hinbekommen, wie man das macht.

Was das Thema interrupts angeht, scheint ja doch komplex zu sein, werd mich da mal einlesen.

Grüße
Thorsten

Den Gedankengang meines Vorredners, auf Interrupte zu setzen, kann ich zwar nachvollziehen, scheint mir in diesem konkreten Anwendungsfall aber nicht notwendig. Ich würde direkt bei den FadeIn () und FadeOut () ansetzen. Problematisch sind eben die ganzen Delays in der Schleife. Auf diese müsste man verzichten, indem man (ähnlich wie es im Beispiel "blink without delay" gemacht wird) auf die verstrichene Zeit zurückgreift.
So müsste um 7:30 Uhr ein Trigger fürs einfaden gesetzt werden. Über eine Definition, wie lange der FadeIn-Effekt dauern soll, kann man dann ausrechnen, zu welchem Zeitpunkt der PWM-Wert geändert werden muss. Nur mal als Beispiel: Änderung der PWM von 0 auf 255 innerhalb von 600 Sekunden (10 Minuten). Um 7:30 wird der FadeIn-Vorgang gestartet, und ca. alle 2,5 s (etwas genauer wären 2344 ms) wird der PWM-Wert inkrementiert. Ist dieser dann 255, setzt man den Trigger fürs FadeIn zurück. Ähnlich verfährt man dann fürs Fadeout bzw. bei den anderen Kanälen.

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?