High-Power-LED Beleuchtung, Probleme mit der RTC-Zeit

Hallo,
ich bin gerade dabei mir eine dimmbare High-Power-LED Beleuchtung für mein Aquarium zu bauen. Hardware technisch ist soweit alles fertig. Ich nutze Konstantstrom LED-Treiber von Mean Well, die einen PWM Anschluss besitzen, mit dem der Ausgang gedimmt werden kann. Über diese Pins soll nun mit einem Arduino Mega2560 ein Tagesablauf simuliert werden.

Um die LEDs dimmen zu können, habe ich eine Formel. Dafür benötige ich allerdings Zeitangaben wie z.B. 6Uhr, die ich mit der Aktuellen Zeit vergleichen kann (time_now).

Programmausschnitt:

#include <DS1307RTC.h>                //Echtzeituhr Bibliothek

//Formel: Helligkeit_Jetzt = ((Helligkeit_Ende-Helligkeit_Start)/((Zeit_Ende-Zeit_Start)/(Zeit_Jetzt-Zeit_Start)))+Helligkeit_Start 
 
if(hour() >= 6 && hour() < 7)                             //Zeit zwischen 6 und 7Uhr
 {
  H_Weiss = ((25-0)/((Zeit_Ende-Zeit_Start)/(time_now-Zeit_Start)))+0       // Von 0 auf 25 dimmen
  analogWrite(Driver_W1, H_Weiss);  
  analogWrite(Driver_W2, H_Weiss);
  analogWrite(Driver_W3, H_Weiss);
 }

Eigentlich kann es nicht soo schwer sein aber ich komme nicht drauf… :frowning: Kann mir jemand sagen wie ich Zeit_Ende und Zeit_Start zu 7Uhr und 6Uhr machen kann, damit ich es mit time_now verrechnen kann?

In deinem Sketch ist nicht zu erkennen, wie du die Zeit aus der RTC ausliest.

Sieh dir dazu die Beispiele der Library an, da wird alles genau gezeigt.

Ich tippe mal Du hast Probleme weil Du Integer Variablen verwendest, die keine Kommastellen haben.
Rechne die Tageszeit in Minuten oder Sekunden um und verwende diese Werte.

Grüße Uwe

uwefed:
Ich tippe mal Du hast Probleme weil Du Integer Variablen verwendest, die keine Kommastellen haben.
Rechne die Tageszeit in Minuten oder Sekunden um und verwende diese Werte.

Das mit Integer sollte kein Problem sein.

Über die Funktion "hour()" erhält er eh nur max. 2 Stellen ohne Kommastellen.

Aber hier fehlt noch einiges am Sketch um weitere Aussagen zu machen.

Hallo,

danke für die schnellen Antworten! Oh stimmt sollte man mit posten... :o

void loop()  
{
//-----------Echtzeituhr------------------- 
  tmElements_t tm;                   //Definiere tmElemente als tm (Zeit und Datum)

  if (RTC.read(tm))                  //RTC Elemente auslesen und in tmElementen speichern
  {
    if (Serial.available())                    //Anzeige Serieller Monitor: Uhrzeit & Datum
    {
      Serial.print("Ok, Zeit = ");             //"OK, Zeit = " auf Monitor ausgeben
      print2digits(tm.Hour);                   //Wert aus "tm.Hour" ausgeben (Stunden)
      Serial.write(':');                       //":" auf Monitor ausgeben
      print2digits(tm.Minute);                 //Wert aus "tm.Minute" ausgeben (Minuten)
      Serial.write(':');                       //":" auf Monitor ausgeben
      print2digits(tm.Second);                 //Wert aus "tm.Second" ausgeben (Sekunden)
      Serial.print(", Date (D/M/Y) = ");       //":" auf Monitor ausgeben
      Serial.print(tm.Day);                    //Wert aus "tm.Day" ausgeben (Tag)
      Serial.write('/');                       //"/" auf Monitor ausgeben
      Serial.print(tm.Month);                  //Wert aus "tm.Moth" ausgeben (Monat)
      Serial.write('/');                       //"/" auf Monitor ausgeben
      Serial.print(tmYearToCalendar(tm.Year)); //Wert aus "tm.Year" ausgeben (Jahr)
      Serial.println();                        //Leerzeile
    }
  }
  else                               //RTC Elemente auslesen fehlgeschlagen
  {
    if (RTC.chipPresent())           //RTC gestoppt => SetTime Programm ausführen
    {
      Serial.println("RTC gestoppt => SetTime");
    }
    else                             //RTC nicht erkannt
    {
      Serial.println("RTC nicht erkannt");
    }
  }

So mache ich es momentan, ist aus dem example der Bibliothek. Bin mir aber halt nicht sicher ob es so überhaupt funktionieren kann.

Ich muss diese Formel hin bekommen: Helligkeit_Ende - Helligkeit_Start
(Zeit_Ende - Zeit_Start) / (Zeit_Jetzt - Zeit_Start)

255 - 50
z.B. (22:00Uhr - 12:00Uhr) / (time_now - 12.00Uhr) //dimmen der LEDs zwischen 12 und 22Uhr

Ich denke ich brauche 12:00Uhr dann im time_t Format. Also die ganze Zeit, nicht nur die Stunde um die Zeit mit der aktuellen Zeit (time_now) zu verrechnen. Die Helligkeit soll dann durch diesen Zeitfaktor dividiert werden.

Diese Formel soll durchgehend angewendet werden und die aktuelle Helligkeit der LEDs auszugeben ( z.B. analogWrite(Treiber1, 150)).

Mein Problem sind halt die Formate. Ich will Zeitformate verrechnen (12:00Uhr und time_now), einen Faktor rausbekommen... z.B 5,5. Dann die Helligkeit z.B. 100 durch diesen Faktor dividieren. Ich weiß ist etwas chaotisch, aber ich suche schon länger nach einer Lösung um einen Tageszyklus hinzubekommen. Mit der Formel dachte ich, ich hätte die Lösung... Aber ich weiß leider nicht wie ich mit den verschiedenen Formaten umgehen muss. Kann mir da jemand helfen, oder hat jemand einen anderen einfacheren Vorschlag? :confused:

Wie Uwe schon in #2 geschrieben hat

Rechne die Tageszeit in Minuten oder Sekunden um und verwende diese Werte.

Was aber zu bedenken ist: Die wahrgenommene Helligkeit von LEDs ist meist nicht proportional zum PWM-"Wert", soll heißen: in den unteren Bereichen (die LED ist dunkler) werden kleine Helligkeitsunterschiede viel stärker wahrgenommen als im oberen Bereich. Also sieht man zum Beispiel zwischen 3 und 5 einen gut wahrnehmbaren Helligkeitsunterschied, zwischen 203 und 205 aber ist praktisch kein Helligkeitsunterschied wahrnehmbar.

Wenn du also ganz "linear" rechnest, kann es sein, dass du keinen linearen "Dimmverlauf" erreichst.
Siehe auch: LED-Fading – Mikrocontroller.net

Ja das wäre super, aber wie geht das? Die RTC und die Time Bibliothek verwirren mich grade etwas. Einzelne Stunden oder Minuten kann ich vergleichen, aber wie das mit der "ganzen Zeit" funktioniert weiß ich nicht. Berechnen will ich ja sowas 12:00Uhr - 11:30 = 00:30

Ich weiß, das wollte ich umgehen indem ich den Ausgang von 0-10 grob geschätzt in einer Stunde hochlaufen lasse, 10-50dann die nächste, 50-255 die nächste.

Wenn du zum Beispiel mit Minuten rechnest, wie wäre es mit: :slight_smile:

12:00 Uhr - 11:30 Uhr
(12 x 60) - ((11 x 60) + 30) = 30

(die Klammern habe ich nur zur besseren Übersicht gesetzt)

Da es langwierig ist, immer die Zeiten abzuwarten, hier ein Testprogramm, das für den Zeitraum 12 bis 22 Uhr die PWM-Werte berechnet. Zuerst wird der lineare, dann der logarithmische Wert berechnet:

/*
  a = Anzahl an Schritte (4, 8, 16, 32, 64, 256) hier 256
  b = Auflösung des PWM's (256, 1024, 65536) hier 256
  y = Errechneter Wert an einer stelle x
      y = pow(2, log2(b) * (x+1) / a) - 1
  32 =  log2(b) / a
  2.4 = Korrekturwert
  0.5 = Rundung
*/
const byte Helligkeit_Ende = 255, Helligkeit_Start = 50, a = 256, b = 8;
const uint16_t Zeit_Ende = 22 * 60 + 0, Zeit_Start = 12 * 60 + 0;
uint16_t Zeit_Jetzt;

void setup() {
  Serial.begin(57600);
  Serial.println("Anfang");
  for (byte Stunde = 12; Stunde < 22; Stunde++) {
    for (byte Minute = 0; Minute < 60; Minute++) {
      Zeit_Jetzt = Stunde * 60 + Minute;
      float Wertlin = 1.0 * (Zeit_Jetzt - Zeit_Start) * (Helligkeit_Ende - Helligkeit_Start) / (Zeit_Ende - Zeit_Start);
      byte Wertlog = ((pow(2, (Wertlin + 1.0) / 32.0)-1.0) * 2.4)+0.5;
      Serial.print(Stunde);
      Serial.print(':');
      if (Minute < 10) Serial.print('0');
      Serial.print(Minute);
      Serial.print("  Wertlin: ");
      Serial.print(Wertlin);
      Serial.print("  Wertlog: ");
      Serial.print(Wertlog);
      Serial.println();
    }
  }
}

void loop() {
}

Anstelle der for-Schleifen setzt Du die Werte aus der RTC, also Minute = now.minute(); Stunde = now.hour();