Hallo zusammen,
ich kenne mich leider mit PIs kaum aus, da ich bisher nur mit Arduino zu tun hatte. Nun suche ich nach einer Art Library (richtiges Wort?) für Sonnenuntergänge und -aufgänge.
Hoffe ihr könnt helfen.
Gruß
-DieMelnone
Hallo zusammen,
ich kenne mich leider mit PIs kaum aus, da ich bisher nur mit Arduino zu tun hatte. Nun suche ich nach einer Art Library (richtiges Wort?) für Sonnenuntergänge und -aufgänge.
Hoffe ihr könnt helfen.
Gruß
-DieMelnone
Tageszeiten/ Sonnenzeiten Library? Schau mal ob du hier fündig wirst!
Die große Frage wäre: Wofür und in welcher Programmiersprache? :s
Für javascript (ob browser oder nodejs) gibt es suncalc (google npm suncalc). Wird in meiner auf nodejs basierenden Heimautomation ioBroker verwendet.
Wofür: Rolladensteuerung
Programmiersprache: egal, da ich nur einen Output nach der Sonne schalten muss, der Rest funktioniert schon.
Tach'chen,
für die Belichtungssteuerung meiner Webcam verwende ich PyEphem.
Das berechnet dir standortgenau Sonnenauf- und Untergang. Konfiguration ist etwas komplex, aber gut mit
Beispielen dokumentiert. Zur "Feinjustierung" kann man sogar die Höhe des Horizonts berücksichtigen,
d.h. ob man sich auf dem Meer, Land oder Stadt befindet. Das funktioniert sehr zuverlässig. Für den Standort
gibst du entweder deine GPS Koordinaten an oder greifst auf eine vordefinierte Datenbank mit diversen
"Groß"städten zurück.
/luetzel
Servus,
ich hab' mal kurz den Datenkraken befragt.
Die sinnvollste Methode schein mir einen kostenlosen Wetterdaten-Anbieter ( weatherunderground scheint so einer zu sein ) zu nutzen, der die Daten gleich als JSON-Struktur liefert ...
Das könntest einfach per curl abfragen und brauchst da nicht herumzurechnen.
-> hier ist der Link <- zu einem Beispiel in deutsch ...
cu,
-ds-
Beinahe jede Programmiersprache bietet Funktionen an, mit denen Du Sonnenauf- undt untergang berechnen kannst. Wie wäre es mit einem Lichtsensor als Alternative?
Alles anzeigen
Servus,
ich hab' mal kurz den Datenkraken befragt.
Die sinnvollste Methode schein mir einen kostenlosen Wetterdaten-Anbieter ( weatherunderground scheint so einer zu sein ) zu nutzen, der die Daten gleich als JSON-Struktur liefert ...
Das könntest einfach per curl abfragen und brauchst da nicht herumzurechnen.
-> hier ist der Link <- zu einem Beispiel in deutsch ...cu,
-ds-
Ich hab mal kurz meine Linksammlung befragt:
http://www.kompf.de/trekka/geoposition.php
Das löst zwar das Problem nicht, hilft aber beim verifizieren.
Und das könnte auch hilfreich sein:
http://www.kompf.de/calendar/index.html
MfG
Jürgen
Die sinnvollste Methode schein mir einen kostenlosen Wetterdaten-Anbieter ( weatherunderground scheint so einer zu sein ) zu nutzen, der die Daten gleich als
Hmm, naja nur mit der library gehts dann auch ohne Internetverbindung ... und in Python ist das ja recht überschaubar.
import datetime
import ephem
# what is the date?
m_now = datetime.date.today()
# set geographic location, latitude and longitude for sunset/sunrise calculation;
# example for cities not in pyephem-list, use: Berlin.lat='52', Berlin.long='13'
Berlin = ephem.Observer()
Berlin = ephem.city('Berlin')
Berlin.elev = 30
Berlin.date = m_now
# calculate next/previous sunset, sunrise and retrieve system time
# for debugging, add .strftime("%Y-%m-%d %H:%M:%S") to time vars SUNRISE, NOON ...
sunrise = ephem.localtime(Berlin.next_rising(ephem.Sun()))
noon = ephem.localtime(Berlin.next_transit(ephem.Sun()))
sunset = ephem.localtime(Berlin.next_setting(ephem.Sun()))
# Twilight calculation, set horizon
# Berlin.horizon = '-6' # Civil
# Berlin.horizon = '-12' # Nautical
# Berlin.horizon = '-18' # Astronomical
Berlin.horizon = '-2' # Civil
# calculate twilight
begin = ephem.Date(Berlin.next_rising(ephem.Sun(), use_center=True))
end = ephem.Date(Berlin.next_setting(ephem.Sun(), use_center=True))
twilight_begin = ephem.localtime(begin)
twilight_end = ephem.localtime(end)
print twilight_begin
print sunrise
print noon
print sunset
print twilight_end
Alles anzeigen
Der Code aus dem Beispiel lässt sich ja auf wenige Zeilen "eindampfen" ... und wenn man es suuupergenau haben möchte, kann man als 'Gimmick' auch noch den Luftdruck vom BMP180 mit einrechnen
Hallo DieMelone,
wenn es dir um mehr als nur um Sonnenauf- und Sonnenuntergang geht, dann kann ich dir auch die Wetterdaten von tutiempo.net empfehlen (ebenfalls kostenneutral). Die bieten einen XML Feed an und ich ziehe mir da die kompletten Wetterdaten für eine 15 Tage Vorhersage auf meiner Wetterstation.
Schau mal hier: Sonnenaufgang und Sonnenuntergang in Bash-Skript berechnen
Ich schalte damit per Funksteckdose sonnenuntergangsabhängig die Außenbeleuchtung an.
Wofür: Rolladensteuerung
Programmiersprache: egal
Egal ist das nicht.
Es macht kaum Sinn alle möglichen Programmiersprachen für ein Projekt zu vermischen - zum Beispiel mit JavaScript könntest du bei einem Bash / Python / Ruby etcpp. Projekt nichts anfangen. Ebenso wenig macht es ohne Internet Verbindung Sinn ein Script zu verwenden dass auf ein Internetportal zurückgreift...
Also sei bitte so nett und liefere mehr Details.
ich rechne das in C nach Geo Koordinaten aus, funktioniert seit einemJahr bei mir auf Arduino
SONNENAUFGANG_H
#ifndef SONNENAUFGANG_H
#define SONNENAUFGANG_H
// C-Programm von http://lexikon.astronomie.info/zeitgleichung/neu.html
// umgeschrieben auf Arduino by 'jurs' for German Arduino forum
extern double pi2;
extern double pi;
extern double RAD;
extern double JulianischesDatum ( int Jahr, int Monat, int Tag, int Stunde, int Minuten, double Sekunden );
extern double InPi(double x);
extern double eps(double T); // Neigung der Erdachse
extern double BerechneZeitgleichung(double &DK,double T);
extern void sonnenaufgang_init(uint16_t loc_year, uint8_t loc_month, uint8_t loc_day);
extern void sonnenauf_untergang_ausgabe(void);
extern char fenster_down_time_str[];
#endif // #ifndef SONNENAUFGANG_H
Alles anzeigen
sonnenaufgang.ino // sonnenaufgang.c
#include "sonnenaufgang.h"
// 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;
//extern char [];
void sonnenauf_untergang_ausgabe(void)
{
Serial.print(F(".\r\n--- Sonnenauf- & -untergang Ausgabe ---\r\n.\r\n"));
if( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
{ while(_i2c_busy); _i2c_busy=1; RTC.getTime(); _i2c_busy=0;
sonnenaufgang_init(RTC.year, RTC.month, RTC.day); // RTC.year, RTC.month, RTC.day
}
/*
Serial.println(F(".\n."));
sonnenaufgang_init(2016, 1, 15);
sonnenaufgang_init(2016, 2, 15);
sonnenaufgang_init(2016, 3, 15);
sonnenaufgang_init(2016, 4, 15);
sonnenaufgang_init(2016, 5, 15);
sonnenaufgang_init(2016, 6, 15);
sonnenaufgang_init(2016, 7, 15);
sonnenaufgang_init(2016, 8, 15);
sonnenaufgang_init(2016, 9, 15);
sonnenaufgang_init(2016, 10, 15);
sonnenaufgang_init(2016, 11, 15);
sonnenaufgang_init(2016, 12, 15);
*/
Serial.print(F(".\r\n--- Sonnenauf- & -untergang Ausgabe ENDE ---\r\n.\r\n"));
} // void sonnenauf_untergang_ausgabe(void)
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 ;
}
extern char down_time_str[];
void sonnenaufgang_init(uint16_t loc_year, uint8_t loc_month, uint8_t loc_day)
{ double JD2000 = 2451545.0;
double JD;
JD = JulianischesDatum(loc_year, loc_month, loc_day, 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);
*/
// meine Koordinaten in dezimal
double T = (JD - JD2000)/36525.0;
double DK;
double h = -50.0/60.0*RAD;
double B = Breite_dezimal *RAD; // geographische Breite
// double B = 50.0*RAD; // geographische Breite
double GeographischeLaenge = Länge_dezimal;
// double GeographischeLaenge = 10.0;
//double Zeitzone = 0; //Weltzeit
//double Zeitzone = 1; //Winterzeit
//double Zeitzone = 2.0; //Sommerzeit
double Zeitzone = 1 + mesz( loc_year, tagesnummer(loc_year, loc_month, loc_day), 12 );
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(loc_year);
Serial.print(F("/"));
Serial.print(loc_month);
Serial.print(F("/"));
Serial.print(loc_day);
Serial.print(F(" -> "));
Serial.print(F("Aufgang "));
Serial.print(AufgangStunden);
Serial.print(F(":"));
if(AufgangMinuten<10.0)
Serial.print(F("0"));
Serial.print(AufgangMinuten);
Serial.print(F(", "));
Serial.print(F("Untergang "));
if (UntergangStunden<10.0)
Serial.print(F("0"));
Serial.print(UntergangStunden);
Serial.print(F(":"));
if (UntergangMinuten<10.0)
Serial.print(F("0"));
Serial.print(UntergangMinuten);
Serial.print(F(" @home"));
((uint8_t)(Zeitzone-1)) ? Serial.print(F(" MESZ Sommerzeit")) : Serial.print(F(" MEZ Winterzeit"));
Serial.println();
sprintf(fenster_down_time_str,"%02d:%02d", UntergangStunden, UntergangMinuten);
// Vergleich mit CalSky.com
// Aufgang : 7h18.4m Untergang : 19h00.6m
} // void sonnenaufgang_init(void)
Alles anzeigen
Aufruf in setup
if(i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307))
{ RTC.getTime();
heute=RTC.day;
sprintf(fenster_ist_time_str, "%02d:%02d", RTC.hour, RTC.minute);
DEBUG_PRINTLN(F("\nsetup"));
DEBUG_PRINT(F("fenster_ist_time_str: ")); DEBUG_PRINTLN(fenster_ist_time_str);
Serial.print(F("up_time:\t")); Serial.println(fenster_up_time_str);
Serial.print(F("alt down_time: ")); Serial.println(fenster_down_time_str);
sonnenauf_untergang_ausgabe();
Serial.print(F("neu down_time: ")); Serial.println(fenster_down_time_str);
Serial.print(F("sollte "));
myGLCD.print(" sein ", LEFT, LINE3);
if( strcmp(fenster_ist_time_str, fenster_up_time_str)>=0 && strcmp(fenster_ist_time_str, fenster_down_time_str)<0 )
{ fenster_status=1;
myGLCD.print("sollte oben ", LEFT, LINE2);
Serial.println(F("oben sein"));
Serial.print(F("down_time: ")); Serial.println(fenster_down_time_str);
myGLCD.print("down", LEFT, LINE6); myGLCD.print((char*)fenster_down_time_str, RIGHT, LINE6);
faehrt=0;
} // if( strcmp(fenster_ist_time_str, fenster_up_time_str)>=0 || strcmp(fenster_ist_time_str, fenster_up_time_str)<0 ) // oben
else
{
fenster_status=-1;
myGLCD.print("sollte unten ", LEFT, LINE2);
Serial.println(F("unten sein"));
Serial.print(F("fenster_up_time: ")); Serial.println(fenster_up_time_str);
myGLCD.print("up ", LEFT, LINE6); myGLCD.print((char*)fenster_up_time_str, RIGHT, LINE6);
faehrt=0;
} // if( !(strcmp(fenster_ist_time_str, fenster_up_time_str)>=0 || strcmp(fenster_ist_time_str, fenster_up_time_str)<0) ) // unten
} // if(i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307))
DEBUG_PRINT(F("\nRF Transmitter is set to Port ")); DEBUG_PRINT(RCsend); DEBUG_PRINTLN(F(" (!int0) ...\n"));
cli(); // disable global interrupts
TIMSKx |= (1 << OCIExA);
sei();
alle_fahren(fenster_status);
Alles anzeigen
.....Wie wäre es mit einem Lichtsensor als Alternative?
weiteren Kabelsalat wollte ich nicht, deswgen Funkaktore Intertechno Rolladen/Jalousie Empfänger
klappt +-2 Minuten bei mir übers Jahr gut
Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!