Hallo,
gibt es einen "einfachen" Sketch, der mir die Sonnen-Auf und Untergangszeiten
berechnen kann.
Ich stelle mir das so vor, das die OrtsKoordinaten und das Datum in einer
Variable stehen. Oder wie auch immer?
Gruß und Dank
Andreas
Das hängt vom Tag im Jahr ab. Den Ort gibt man fest vor, da die Uhr meistens nur an einem Ort steht.
Diese Formel ist ziemlich einfach:
http://lexikon.astronomie.info/zeitgleichung/
Wie genau das mit floats wird, müsste man ausprobieren
Du kannst die Werte auch genauer vorberechnen und einer Tabelle im Flash speichern.
http://forum.arduino.cc/index.php?topic=126740.0
beschreibt eine Sonnenfolger für Solaranwendungen. Daraus lassen sich auch Sonnenaufgang und Untergang errechnen.
Grüße Uwe
Hallo,
"Sonnenfolger" Jaa! Daraus errechne ich mir dann die Sonnen Auf- und
Untergangszeiten. Netter Versuch…
Die Seite mit der "einfachen" Formel kenne ich. Das habe ich schon vor langer
Zeit einmal probiert. Seid dem würde ich jeden Tag im Dunklen erleben- oder
in der Wüste leben. Deswegen fragte ich nach einfach.
Einen Sketch habe ich bislang gefunden, aber nach dem, kann ich es auch
selber probieren. Mal sehen was wird.
Gruß und Spaß und Danke schön.
Andreas
P.S.
hier sind zwei solche Spezialisten
http://swfltek.com/arduino/time32.html
http://www.andregoncalves.info/ag_blog/?p=47
Wie auf der oben verlinkten Seite schon steht: einfach und halbwegs genau beissen sich.
Astronomische Berechnungen sind nunmal nicht ganz simpel-aber soo schwer nun auch wieder nicht.
Der Quelltext für die Java-Skript-Version ist frei einsehbar, so schwer isses nicht, das auf den Dino umnzuschreiben, denke ich.
Leider hab ich für meine Uhr im Moment keine Zeit (bzw. keinen Dino frei, aber der nächste ist bereits auf dem Weg zu mir 8)), der wollt ich das eigentlich auch noch implementieren.
Serenifly:
Wie genau das mit floats wird, müsste man ausprobieren
Das wird in unseren Breitengraden auf ca. +/-2 Minuten genau.
Und das liegt nicht an den relativ ungenauen float Gleitkommazahlen, sondern daran, dass in der dortigen Zeitgleichung ohne das Kalenderjahr gerechnet wird. Stattdessen wird so getan als wenn die Ellipsenbahn um die Sonne jedes Jahr nach 365 Tagen am selben Punkt beginnt, was nicht ganz korrekt ist. Der Erdumlauf um die Sonne dauert nämlich ca. 365,25 Tage, aber der Code geht davon aus, dass die Erde nur 365 Tage für die Ellipse benötigt, und alle vier Jahre im Schaltjahr kennt der Code den 29.02. nicht und verliert den Tag, so dass es sich dann wieder ausgleicht. Dadurch sind die Auf- und Untergangszeiten um bis zu einen Tag falsch berechnet und weil sich die Zeiten in unseren Breitengraden pro Tag um ca. 2 Minuten ändern können ist das dann zugleich der auftretende maximale Rechenfehler.
Genauere Berechnungen sind möglich mit Berücksichtigung von Kalenderjahren und taggenauer Rechnung.
Rabenauge:
Der Quelltext für die Java-Skript-Version ist frei einsehbar, so schwer isses nicht, das auf den Dino umnzuschreiben, denke ich.
Leider hab ich für meine Uhr im Moment keine Zeit (bzw. keinen Dino frei, aber der nächste ist bereits auf dem Weg zu mir 8)), der wollt ich das eigentlich auch noch implementieren.
Auf derselben Seite ist auch ein taggenauer Code mit Berücksichtigung des Kalenderjahrs und im C-Quellcode vorhanden:
Der unten auf der Seite abgedruckte C-Code läuft auf Arduino völlig einwandfrei, wenn man die drei ersten Zeilen mit den includes entfernt und die Streaming Bildschirmausgaben ("cout << "Aufgang "<< AufgangStunden << ":";" etc.) auf Serial.print Ausgabe umschreibt.
Daraus kann man leicht eine in sich gekapselte Funktion mit Parametern machen, die beim Funktionaaufruf für jedes Datum und jede geographische Position zwischen den Polarkreisen die korrekten Auf- und Untergangszeiten errechnet. Nur die Fälle von Mitternachtssonne und Polarnacht, wo es nördlich und südlich der Polarkreise an manchen Tagen keine Sonnenauf- oder -untergänge gibt, werden von dem Code wohl nicht korrekt ausgegeben, sondern die Spezialfälle Mitternachtssonne und Polarnacht werden in beiden Fällen ausgegeben mit "Sonnenaufgang 0:00" und "Sonnenuntergang 0:00", woraus man wenigstens erkennen kann, dass an diesem Tag ein Spezialfall vorliegt, allerdings nicht, welcher der beiden Fälle vorliegt (allerdings sollte das aufgrund des Breitengrads und der Jahreszeit klar sein).
Hallo,
"läuft auf Arduino völlig einwandfrei"
Naa! Das werde ich mal probieren- ist ja ein Lichtblick. Denn das was ich bis
jetzt gefunden habe ist mehr als zweifelhaft. Was mir Sorgen bereitet hat
sind die Sin/Cos und Grad/Rad und Bogenberechnungen. Nicht der Weg, sondern
das dem Arduino beibringen. Nachdem ich das aber nachgelesen habe, ist das
nicht so schwer, der Arduino ist da recht fähig.
Gruß und Dank
Andreas
jurs:
Das wird in unseren Breitengraden auf ca. +/-2 Minuten genau.
Und das liegt nicht an den relativ ungenauen float Gleitkommazahlen, sondern daran, dass in der dortigen Zeitgleichung ohne das Kalenderjahr gerechnet wird.
Das steht ja auch klar so dort. Wobei diese Genauigkeit für die meisten Anwendungen ausreichen wird. 
Ich dachte halt dass durch die vielen Gleitkomma-Konstanten und Trigonometrischen Berechnungen vielleicht noch ein paar kleine Fehler hinzukommen.
sin/cos/arccos und das alles gibt es in math.h. Das ist automatisch inkludiert und man muss nichts machen! Siehe die von den Arduino-Machern totgeschwiegende AVR libc Doku:
http://www.nongnu.org/avr-libc/user-manual/group__avr__math.html
SkobyMobil:
Naa! Das werde ich mal probieren- ist ja ein Lichtblick. Denn das was ich bis
jetzt gefunden habe ist mehr als zweifelhaft. Was mir Sorgen bereitet hat
sind die Sin/Cos und Grad/Rad und Bogenberechnungen. Nicht der Weg, sondern
das dem Arduino beibringen.
Im Gegensatz zu Taschenrechnern, die meist zwischen verschiedenen Winkelmaßen bei der Verwendung von Winkelfunktionen umschaltbar sind (z.B. DEG-RAD-GRAD), arbeiten die Winkelfunktionen von Programmiersprachen eigentlich immer im Bogenmaß (rad), so auch bei C/C++. Und notwendige Umrechnungen ins Bogenmaß, z.B. weil die geographische Position in Längen- und Breitengraden angegeben wird, führt das C-Programm schon durch wo es notwendig ist, bevor die C-Winkelfunktionen aufgerufen werden.
Falls Du Schwierigkeiten hast, die "main" Funktion in eine ordentliche Arduino-Funktion zu verpacken, der man einfach Breitengrad, Längengrad, Jahr, Monat, Tag als Parameter übergibt und die dann die Auf- und Untergangszeiten in geeigneter Form zurückliefert, gib einfach Bescheid, dann mache ich Dir gerne einen Vorschlag dafür!
Hallo jurs,
ist ja nett, das Du mir helfen möchtest- aber ich bekomme nicht einmal
ein "C-Programm" in den Arduino. Aber wohin damit?
Ich kann zwar C&P, aber die Fehler die dort dann auflaufen…
Das ist noch ne´ NUMMER zu groß!
Gruß und Dank
Andreas
SkobyMobil:
ist ja nett, das Du mir helfen möchtest- aber ich bekomme nicht einmal
ein "C-Programm" in den Arduino. Aber wohin damit?
Ich kann zwar C&P, aber die Fehler die dort dann auflaufen…
Das ist noch ne´ NUMMER zu groß!
Arduino-Sketche sind auch nur C-Programme.
Aus "main()" wird für einen Arduino-Sketch einfach mal "setup()" und die Ausgabe leite ich auf die serielle Schnittstelle, schon läßt sich das Programm kompilieren und ohne größere Änderungen auf den Arduino hochladen:
// C-Programm von http://lexikon.astronomie.info/zeitgleichung/neu.html
// umgeschrieben auf Arduino by 'jurs' for German Arduino forum
double pi2=6.283185307179586476925286766559;
double pi=3.1415926535897932384626433832795;
double RAD = 0.017453292519943295769236907684886;
double JulianischesDatum ( int Jahr, int Monat, int Tag,
int Stunde, int Minuten, double Sekunden )
// Gregorianischer Kalender
{
int Gregor;
if (Monat<=2)
{
Monat=Monat +12;
Jahr = Jahr -1;
}
Gregor = (Jahr/400)-(Jahr/100)+(Jahr/4); // Gregorianischer Kalender
return 2400000.5+365.0*Jahr - 679004.0 + Gregor
+ int(30.6001*(Monat+1)) + Tag + Stunde/24.0
+ Minuten/1440.0 + Sekunden/86400.0;
}
double InPi(double x)
{
int n = (int)(x/pi2);
x = x - n*pi2;
if (x<0) x +=pi2;
return x;
}
double eps(double T) // Neigung der Erdachse
{
return RAD*(23.43929111 + (-46.8150*T - 0.00059*T*T + 0.001813*T*T*T)/3600.0);
}
double BerechneZeitgleichung(double &DK,double T)
{
double RA_Mittel = 18.71506921
+ 2400.0513369*T +(2.5862e-5 - 1.72e-9*T)*T*T;
double M = InPi(pi2 * (0.993133 + 99.997361*T));
double L = InPi(pi2 * ( 0.7859453 + M/pi2
+ (6893.0*sin(M)+72.0*sin(2.0*M)+6191.2*T) / 1296.0e3));
double e = eps(T);
double RA = atan(tan(L)*cos(e));
if (RA<0.0) RA+=pi;
if (L>pi) RA+=pi;
RA = 24.0*RA/pi2;
DK = asin(sin(e)*sin(L));
// Damit 0<=RA_Mittel<24
RA_Mittel = 24.0*InPi(pi2*RA_Mittel/24.0)/pi2;
double dRA = RA_Mittel - RA;
if (dRA < -12.0) dRA+=24.0;
if (dRA > 12.0) dRA-=24.0;
dRA = dRA* 1.0027379;
return dRA ;
}
void setup()
{
Serial.begin(9600);
double JD2000 = 2451545.0;
double JD;
JD = JulianischesDatum(2005,9,30,12,0,0); // Testdatum
/*
// manuelle Dateneingabe
int year, month, day;
cout << "Berechnung Sonnenufgang und -untergang" << endl;
cout << "Jahr (YYYY): "; cin >> year;
cout << "Monat (MM): "; cin >> month;
cout << "Tag (DD): "; cin >> day;
JD = JulianischesDatum(year,month,day,12,0,0);
*/
double T = (JD - JD2000)/36525.0;
double DK;
double h = -50.0/60.0*RAD;
double B = 50.0*RAD; // geographische Breite
double GeographischeLaenge = 10.0;
//double Zeitzone = 0; //Weltzeit
//double Zeitzone = 1; //Winterzeit
double Zeitzone = 2.0; //Sommerzeit
double Zeitgleichung = BerechneZeitgleichung(DK,T);
double Minuten = Zeitgleichung*60.0;
double Zeitdifferenz = 12.0*acos((sin(h) - sin(B)*sin(DK)) / (cos(B)*cos(DK)))/pi;
double AufgangOrtszeit = 12.0 - Zeitdifferenz - Zeitgleichung;
double UntergangOrtszeit = 12.0 + Zeitdifferenz - Zeitgleichung;
double AufgangWeltzeit = AufgangOrtszeit - GeographischeLaenge /15.0;
double UntergangWeltzeit = UntergangOrtszeit - GeographischeLaenge /15.0;
double Aufgang = AufgangWeltzeit + Zeitzone; // In Stunden
if (Aufgang<0.0) Aufgang +=24.0;
else if (Aufgang>=24.0) Aufgang -=24.0;
double Untergang = UntergangWeltzeit + Zeitzone;
if (Untergang<0.0) Untergang +=24.0;
else if (Untergang>=24.0) Untergang -=24.0;
int AufgangMinuten = int(60.0*(Aufgang - (int)Aufgang)+0.5);
int AufgangStunden = (int)Aufgang;
if (AufgangMinuten>=60.0) { AufgangMinuten-=60.0; AufgangStunden++; }
else if (AufgangMinuten<0.0) {
AufgangMinuten+=60.0; AufgangStunden--;
if (AufgangStunden<0.0) AufgangStunden+=24.0;
}
int UntergangMinuten = int(60.0*(Untergang - (int)Untergang)+0.5);
int UntergangStunden = (int)Untergang;
if (UntergangMinuten>=60.0) { UntergangMinuten-=60.0; UntergangStunden++; }
else if (UntergangMinuten<0) {
UntergangMinuten+=60.0; UntergangStunden--;
if (UntergangStunden<0.0) UntergangStunden+=24.0;
}
Serial.print("Aufgang ");
Serial.print(AufgangStunden);
Serial.print(":");
if (AufgangMinuten<10.0) Serial.print("0");
Serial.print(AufgangMinuten);
Serial.println();
Serial.print("Untergang ");
Serial.print(UntergangStunden);
Serial.print(":");
if (UntergangMinuten<10.0) Serial.print("0");
Serial.print(UntergangMinuten);
// Vergleich mit CalSky.com
// Aufgang : 7h18.4m Untergang : 19h00.6m
}
void loop()
{}
Die Stellenzahl der Konstanten sind natürlich für den Arduino nur Fake, denn die einfach genauen Gleitkommazahlen sind nur auf 6 bis 7 signifikante Stellen genau.
Wenn ich die Tage mal Zeit finde, mache ich daraus mal eine schön mit Parametern aufrufbare Funktion.
Und wie ich gerade sehe, kann man dasselbe Programm nicht nur zur Berechnung der Sonnenauf- und Untergangszeiten verwenden, sondern mit einer relativ einfachen Erweiterung auch zur Berechnung von Dämmerungszeiten. Wenn man für die Konstante "h" nämlich andere Werte als -50 Bogenminuten ansetzt, könnte man auch die Zeiten für die bürgerliche, nautische und/oder astronomische Dämmerung errechnen:
Also die Zeiten, zu denen man nach Sonnenuntergang (bzw. vor Sonnenaufgang) noch im Freien Zeitung lesen kann, bei freiem Blick auf den Horizont noch die Horizontlinie erkennen kann, oder ab wann es pechschwarze Nacht ist. Obwohl das natürlich nur Rechenwerte wären, die nichts über die tatsächliche Helligkeit während der Dämmerung aussagen, da die Helligkeit nach Sonnenuntergang auch stark von der Bewölkung abhängig ist.
Die Zeiten für den Beginn der Morgendämmerung oder das Ende der Abenddämmerung brauchst Du nicht, sondern nur Sonnenaufgang und Sonnenuntergang? Oder sollten auch die Zeiten der Morgen-/Abenddämmerung berechnet werden können?
Hallo jurs,
da bist Du schneller gewesen..
es läuft, es läuft...Ausgabe auf LCD
lesen bildet,
Aufgang 7:18, Untergang 19:00 ?
Jetzt lese ich mal, was Du "anders" gemacht hast.
Gruß und Dank
Andreas
Hallo jurs,
da habe ich aber etwas völlig anderes gemacht:
#include <LiquidCrystal.h>
const int LcdHb = 30;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
}
using namespace std;
double pi2=6.283185307179586476925286766559;
double pi=3.1415926535897932384626433832795;
double RAD = 0.017453292519943295769236907684886;
double JulianischesDatum ( int Jahr, int Monat, int Tag,
int Stunde, int Minuten, double Sekunden )
// Gregorianischer Kalender
{
int Gregor;
if (Monat<=2)
{
Monat=Monat +12;
Jahr = Jahr -1;
}
Gregor = (Jahr/400)-(Jahr/100)+(Jahr/4); // Gregorianischer Kalender
return 2400000.5+365.0*Jahr - 679004.0 + Gregor
+ int(30.6001*(Monat+1)) + Tag + Stunde/24.0
+ Minuten/1440.0 + Sekunden/86400.0;
}
double InPi(double x)
{
int n = (int)(x/pi2);
x = x - n*pi2;
if (x<0) x +=pi2;
return x;
}
double eps(double T) // Neigung der Erdachse
{
return RAD*(23.43929111 + (-46.8150*T - 0.00059*T*T + 0.001813*T*T*T)/3600.0);
}
double BerechneZeitgleichung(double &DK,double T)
{
double RA_Mittel = 18.71506921
+ 2400.0513369*T +(2.5862e-5 - 1.72e-9*T)*T*T;
double M = InPi(pi2 * (0.993133 + 99.997361*T));
double L = InPi(pi2 * ( 0.7859453 + M/pi2
+ (6893.0*sin(M)+72.0*sin(2.0*M)+6191.2*T) / 1296.0e3));
double e = eps(T);
double RA = atan(tan(L)*cos(e));
if (RA<0.0) RA+=pi;
if (L>pi) RA+=pi;
RA = 24.0*RA/pi2;
DK = asin(sin(e)*sin(L));
// Damit 0<=RA_Mittel<24
RA_Mittel = 24.0*InPi(pi2*RA_Mittel/24.0)/pi2;
double dRA = RA_Mittel - RA;
if (dRA < -12.0) dRA+=24.0;
if (dRA > 12.0) dRA-=24.0;
dRA = dRA* 1.0027379;
return dRA ;
}
int main()
{
Serial.begin(19200);
lcd.begin(20, 4);
pinMode(LcdHb, OUTPUT);
digitalWrite(LcdHb, HIGH);
double JD2000 = 2451545.0;
double JD;
JD = JulianischesDatum(2005,9,30,12,0,0); // Testdatum
/*
// manuelle Dateneingabe
int year, month, day;
cout << "Berechnung Sonnenufgang und -untergang" << endl;
cout << "Jahr (YYYY): "; cin >> year;
cout << "Monat (MM): "; cin >> month;
cout << "Tag (DD): "; cin >> day;
JD = JulianischesDatum(year,month,day,12,0,0);
*/
double T = (JD - JD2000)/36525.0;
double DK;
double h = -50.0/60.0*RAD;
double B = 50.0*RAD; // geographische Breite
double GeographischeLaenge = 10.0;
//double Zeitzone = 0; //Weltzeit
//double Zeitzone = 1; //Winterzeit
double Zeitzone = 2.0; //Sommerzeit
double Zeitgleichung = BerechneZeitgleichung(DK,T);
double Minuten = Zeitgleichung*60.0;
double Zeitdifferenz = 12.0*acos((sin(h) - sin(B)*sin(DK)) / (cos(B)*cos(DK)))/pi;
double AufgangOrtszeit = 12.0 - Zeitdifferenz - Zeitgleichung;
double UntergangOrtszeit = 12.0 + Zeitdifferenz - Zeitgleichung;
double AufgangWeltzeit = AufgangOrtszeit - GeographischeLaenge /15.0;
double UntergangWeltzeit = UntergangOrtszeit - GeographischeLaenge /15.0;
double Aufgang = AufgangWeltzeit + Zeitzone; // In Stunden
if (Aufgang<0.0) Aufgang +=24.0;
else if (Aufgang>=24.0) Aufgang -=24.0;
double Untergang = UntergangWeltzeit + Zeitzone;
if (Untergang<0.0) Untergang +=24.0;
else if (Untergang>=24.0) Untergang -=24.0;
int AufgangMinuten = int(60.0*(Aufgang - (int)Aufgang)+0.5);
int AufgangStunden = (int)Aufgang;
if (AufgangMinuten>=60.0) { AufgangMinuten-=60.0; AufgangStunden++; }
else if (AufgangMinuten<0.0) {
AufgangMinuten+=60.0; AufgangStunden--;
if (AufgangStunden<0.0) AufgangStunden+=24.0;
}
int UntergangMinuten = int(60.0*(Untergang - (int)Untergang)+0.5);
int UntergangStunden = (int)Untergang;
if (UntergangMinuten>=60.0) { UntergangMinuten-=60.0; UntergangStunden++; }
else if (UntergangMinuten<0) {
UntergangMinuten+=60.0; UntergangStunden--;
if (UntergangStunden<0.0) UntergangStunden+=24.0;
}
lcd.setCursor(0,0);
lcd.print( "Aufgang ");
lcd.print(AufgangStunden);
lcd.print(":");
// if (AufgangMinuten<10.0)
//{lcd.print("0");
lcd.print(AufgangMinuten);
// }
lcd.setCursor(0, 2);
lcd.print("Untergang ");
lcd.print(UntergangStunden);
lcd.print(":");
if (UntergangMinuten<10.0)
{lcd.print("0");
lcd.print(UntergangMinuten);
}
// Vergleich mit CalSky.com
// Aufgang : 7h18.4m Untergang : 19h00.6m
return 0;
}
Ich sage mal bis hierher Danke schön, ich muss da jetzt mal mit fummeln...
Also, Gruß und Dank
Andreas
Die Definitionen von Pi kann man sich übrigens sparen. Das gibt es in math.h schon mit M_PI. 2 * Pi (oder Tau 
) ist leider nicht drin.
Hallo jurs,
"Morgendämmerung oder das Ende der Abenddämmerung"
Ich versuche mal Dir denn Sinn (meinen) zu erklären.
Ich bin dabei mir ein EnergieManagemant zu "bastel". Dazu gehört es auch
eigene Gewohnheiten zu erkennen.
Also, wann macht man (Frau) das Licht an? Wenn es "dunkel" ist"
Ich wollte die Brenndauer der einzelnen Beleuchtungen mit einem Lichtsensor
messen. Es wird dunkel, der Sensor erfaßt das, das Licht geht an, - ZeitStempel.
Da gibt es nur ein Problem, wenn ich das Licht anmache, wird es wieder "hell"
Dann dachte ich an einen Außensensor, einziger vernünftiger Platz ist aber
das Dach dafür. Müll!
Wenn ich es aber über SonnenAuf/ und Untergang mache, dann kann ich den
Sensor ca. eine halbe Stunde vor Sonnenuntergang scharf machen. Es ist
nämlich vor Sonnenuntergang immer gleich hell, es verschieben sich nur die
Zeiten. Bewölkung sollte man eigentlich vernachlässigen können.
Das ist der Sinn (meiner) des ganzen.
Hallo Serenifly,
"sparen. Das gibt es in math.h schon"
das scheint auch ohne zu funktionieren. Ich mag die Lib´s nicht besonders.
Schau´n wir mal.
Gruß und Spaß
Andreas
Hallo,
das funktioniert, nicht zu fassen! Hat auch Zeiger für Sommer/Winterzeit und Weltzeit.
Ich habe mich nach Sketchen wirklich "blöde" gesucht. Was es zu Hauf gibt
sind Haustierhalter, die ihre Fische mit RGB Beleuchtung in den Wahnsinn
treiben…
Und dann kommt hier "einer" aus einem DEUTSCHEN Forum…
SonnenAuf- und Untergang? phh…
… und knallt Dir das Ding eben mal vor die Füsse.
Mein lieber Scholli, Hochachtung!
Gruß
Andreas
Hallo,
" Wenn man für die Konstante "h" nämlich andere Werte als -50 Bogenminuten ansetzt,"
Ja, dann stimmen aber die Zeiten nicht, das läuft völig aus dem Ruder.
18/2 - SA - 07:32 - Dämmerung Programm 07:37 - ist aber 06:55
15/6 - SA - 03:55 - Dämmerung Programm 04:01 - ist aber 03:20
da gibt es wohl noch andere Schrauben. "Sonne" funktioniert aber.
Gruß und Spaß
Andreas
Hallo
Ja der kann was
bin auch immer wieder erstaunt
Grüße
Ratlos
Hallo,
ich habe den Code in mein Programm implentiert. Es funktioniert einwandfrei.
Die Variablen für das Julianische Datum werden von meiner ChronoDot geliefert.
Damit ist es mir möglich eine Schaltuhr mit "AstroProgramm" für die
Aussenbeleuchtung zu realisieren. Längen und Breitengrade spielen hier nur
eine zweitrangige Rolle, weil- so eine "BastelerHütte" kann ja nicht umziehen.
Die Geschichte mit dem Lichtsensor nimmt jetzt auch Gestalt an.
Hier mal ein Datenblatt von so einer Schaltuhr:
http://www.theben.de/var/theben/storage/ilcatalogue/files/pdf/Handbuch_PI_Handbuch_SELEKTA_de.PDF
Hier gibt es noch andere Info´s für "ZeitSchaltUhr"
http://www.patent-de.com/G04G_15_00.html
Da müßte auch etwas mit der Heizung gehen. Vielleicht könnte man die Vorlauf-
Temperatur um einige wenige Grad senken, wenn die Sonne z.B. "auf der Küche
steht." Da könnte man sich einiges Einfallen lassen…
Gruß und Spaß
Andreas
SkobyMobil:
das funktioniert, nicht zu fassen! Hat auch Zeiger für Sommer/Winterzeit und Weltzeit.
Ich habe mich nach Sketchen wirklich "blöde" gesucht.
Übrigens reizt der gepostete Code die Genauigkeit der "einfach" genauen "float" Gleitkommazahlen des Arduino immer noch nicht voll aus.
Die Berechnung nach dem Schema auf Bid on the domain astronomie.info now | nicsell ist nur +/-5 Minuten genau, da diese noch nicht einmal die Ellipsenbahn der Erde um die Sonne taggenau ausrechnet und sich dabei +/- 1 Tag verrechnet. Das Schema rechnet ohne Jahreszahlen und geht fälschlicherweise davon aus, dass die Erdbahn jedes Jahr am 01. Januar am selben Punkt der Umlauf-Ellipse beginnt.
Die Berechnung nach dem C-Quellcode auf Bid on the domain astronomie.info now | nicsell ist genauer, da an jedem Tag der richtige Punkt der Erde auf der Ellipsenbahn zugrunde gelegt wird. Aber die Abweichungen der Auf- und Untergangszeiten zu den hochgenau berechneten Zeiten auf http://www.calsky.com/ betragen oft immer noch über zwei Minuten.
Falls es jemanden interessiert: Die Auf- und Untergangszeiten lassen sich auch auf einem Arduino mit float-Gleitkommazahlen "einfacher Genauigkeit" noch genauer berechnen, wenn man noch etwas aufwändiger rechnet. Man müßte nämlich nicht nur den exakten Punkt der Erde auf der Ellipsenbahn um die Sonne zu einem gegebenen Datum berücksichtigen, sondern auch einen anderen Effekt durch die Ellipsität der Erdbahn um die Sonne, nämlich dass der Durchmesser der Sonne mal 2% größer und mal 2% kleiner zu sein scheint als der mittlere Durchmesser. Je flacher die Sonne auf- oder untergeht, einen desto größeren Effekt macht der durch die verschiedene Entfernung Erde-Sonne bedingte Größenunterschied der Sonnenscheibe bei den Auf- und Untergangszeiten aus, denn der Sonnenauf-/untergang ist nicht nach der Mitte der Sonnenscheibe definiert, sondern danach, wann der obere Rand der Sonnenscheibe den Horizont berührt. Und das führt bei einem größeren Sonnenscheibendurchmesser zu früheren Auf- und späteren Untergangszeiten im Vergleich zu einem kleineren Sonnenscheibendurchmesser bei größerem Sonnenabstand.
Die Formeln dafür kann man aus den Excel- und OpenOffice-Kalkulationstabellen entnehmen und auf Arduino umsetzen:
http://www.esrl.noaa.gov/gmd/grad/solcalc/calcdetails.html
Falls jemand Interesse an so genau berechneten Auf- und Untergangszeiten auf dem Arduino hat und das nicht selbst hinbekommt, könnte ich mal was für Arduino zusammenschreiben und posten.
Übrigens gibt es drei verschiedene Dämmerungszeiten, für bürgerliche, nautische und astronomische Dämmerung. Wenn man Dämmerungszeiten zwischen verschiedenen Programmen und Formeln vergleicht, muss man genau aufpassen, dass man nicht zum Beispiel die Zeiten für bürgerliche Dämmerung (Zeitunglesen im Freien ist noch möglich) mit Zeiten für nautische Dämmerung (auf dem Meer läßt sich die Horizontlinie noch klar erkennen) miteinander vergleicht, denn die weichen immer erheblich voneinander ab.