Seite auswählen

Sonnenstandsberechnung für die intelligente Betätigung von Rolladen, Markisen und Lampen

,
Sonnenstandsberechnung für die intelligente Betätigung von Rolladen, Markisen und  Lampen
Print Friendly, PDF & Email

Update 07.04.2016: Alternatives Skript mit weniger Variablennamen

Grundlagen

Die Sonnenposition wird beschrieben mit der Sonnen_Elevation (Winkel zur Horizontalen) und dem Sonnen_Azimut (Winkel in der Horizontalen, von Norden aus gemessen wie bei der Kompassrose). Beide Grössen sind unentbehrlich für eine jahreszeitabhängige Betätigung von Rolladen für die Nacht, Rolladen für die Beschattung , Jalousien mit variablem Lamellenwinkel, Markisen und letztlich auch für die dämmerungsabhängige Beleuchtung. Professionelle Systeme zur Hausautomation stellen diese Funktion oft nur optional mit Aufpreis zur Verfügung !
Zur Sonnenstandsberechnung hatte ich bereits ein Skript erstellt, das mit mehreren linearen Interpolationsverfahren die Sonnenposition mehr oder weniger genau berechnet. http://homematic-forum.de/forum/viewtopic.php?f=31&t=17300#p140282 Theorie dazu gibt´s hier: http://de.wikipedia.org/wiki/Sonnenstand
Im Hinblick auf die weitere Verbesserung der Berechnung wird hier nun ein umfangreicheres HM-Skript beschrieben, das die Sonnenposition relativ genau für die gesamten 24h eines Tages berechnet. Durch die Verfügbarkeit brauchbarer Daten der Sonnenposition auch in der Nacht (wenn die Sonne bereits unter dem Horizont ist, Elevation negativ), können auch nachtabhängige Steuerungsaufgaben stufenlos und dämmerungsabhängig einfach gelöst werden. Zeitsprünge durch Umstellung von Sommer- auf Winterzeit entfallen durch diese Steuerungsart vollständig.

Hier das Kochrezept

1.) Sicherstellen, dass in der HM-Zeit- und Positionseinstellung auch der richtige Breitengrad des eigenen Standortes (hier hilft Google Earth !) und die richtige Zeitzoneneinstellung für Deutschland „CET/CEST (UTC +1/+2)“ eingetragen sind.
2.) Zwei Systemvariablen anlegen_
sonne_elevation mit Variablentyp Zahl von -180 bis +180 grad
sonne_azimut mit Variablentyp Zahl von-360 bis +360 grad
3.) Ein einfaches WebUI-Programm anlegen, in dem man beispielsweise all 4 Minuten das folgende Skript aufruft:
HM-Skript   
!berechg sonne_elevation, sonne_azimut; stand 14.03.2014
!Verfasser: funkleuchtturm
real phi = system.Latitude(); !Breitengrad holen
phi = 0.017453292 * phi; !umwandeln in bogenmass
!####### sin_phi und cos_phi mit taylorreihe berechnen
real temp = phi * phi;
real sin_phi =phi * ((temp * temp * 0.0083334) +1.0 - (temp * 0.1666667)); !sinus-naeherung
real cos_phi = (temp *temp *0.0416667)  + 1.0 - (temp * 0.5); !cosinus-naeherung
!### berechnung sonnenzeit, alle zeiten in minuten ########
integer zeit_min = system.Date("%M").ToInteger() + 60*system.Date("%H").ToInteger();
integer tagesbeginn_min = system.SunriseTime("%M").ToInteger() + 60*system.SunriseTime("%H").ToInteger();
integer tagesende_min = system.SunsetTime("%M").ToInteger() + 60* system.SunsetTime("%H").ToInteger();
integer sonnenzeit =zeit_min + 720 - 0.5 *(tagesbeginn_min +tagesende_min);
if (sonnenzeit > 1440) {sonnenzeit = sonnenzeit -1440;}
if (sonnenzeit < 1) {sonnenzeit = 1440 + sonnenzeit;}
boolean nachmittag =false;
if (sonnenzeit > 720) {sonnenzeit =sonnenzeit - 720; nachmittag = true; }
else {sonnenzeit =720 -sonnenzeit;}
!##### berechnung sin_tau und cos_tau ############
real tau = 0.00436332313 * sonnenzeit;   ! 15/60  * pi /180 * sonnenzeit  [0 < tau < pi ]
if (tau < 1.570796327)
{temp = tau * tau;
real sin_tau =tau * ((temp * temp *  0.0083334) +1.0 - (temp *0.1666667));
tau= 1.570796327 - tau;
temp = tau * tau;
real cos_tau =tau * ((temp * temp *  0.0083334) +1.0 - (temp * 0.1666667));}
else
{real tau1  =3.141592654 - tau;
temp = tau1 * tau1;
real sin_tau =tau1 * ((temp * temp *  0.0083334) +1.0 - (temp * 0.1666667));
tau = tau  -  1.570796327;
temp = tau * tau;
real cos_tau = (tau) *(-1.0)* ((temp * temp *  0.0083334) +1.0 - (temp * 0.1666667));}
!##### berechnung delta #######################
integer tageszahl = system.Date("%j").ToInteger();
tageszahl = tageszahl +10;
if (tageszahl > 365) {tageszahl = tageszahl - 365;}
if (tageszahl < 92) {real tag = 0.0172142 *tageszahl;temp = tag * tag;
real delta = (-0.410152) *((temp *temp *0.041666)  + 1.0 - (temp * 0.5));}
if ((tageszahl >91) && (tageszahl < 184)) {tageszahl = 183 - tageszahl; real tag = 0.0172142 *tageszahl;
temp = tag * tag;  real delta = (0.410152) *((temp *temp *0.041666)  + 1.0 - (temp * 0.5));}
if ((tageszahl >183) && (tageszahl < 275)) {tageszahl = tageszahl - 183; real tag = 0.0172142 *tageszahl;
temp = tag * tag;  real delta = (0.410152) *((temp *temp *0.041666)  + 1.0 - (temp * 0.5));}
if ((tageszahl >274) && (tageszahl < 366)) {tageszahl = 365 - tageszahl; real tag = 0.0172142 *tageszahl;
temp = tag * tag;  real delta = (-0.410152) *((temp *temp *0.041666)  + 1.0 - (temp * 0.5));}
!##### berechnung sin_delta, cos_delta  #######################
temp = delta * delta;
real sin_delta =delta * ((temp * temp *  0.0083334) +1.0 - (temp * 0.1666667)); !sinus-naeherung
real cos_delta = (temp *temp *0.0416667)  + 1.0 - (temp * 0.5); !cosinus-naeherung
!##### berechnung tan_delta  mit stueckweiser linearisierung des tan  #######################
boolean vvorzeichen = true;
if (delta< 0.0) {vvorzeichen = false; delta = (-1.0) *delta;}
real tan_delta = 1.0233 * delta;
if (delta >=0.2618) {tan_delta = (1.1822*delta) - 0.0416;}
if (vvorzeichen == false) {tan_delta = (-1.0) * tan_delta;}
!##### berechnung sin_elevation und tan_azimut #######################
real sin_elevation = (sin_phi * sin_delta) +( cos_phi * cos_delta * cos_tau);
temp = sin_elevation * sin_elevation;
real sonne_elevation = sin_elevation * (1.0 + (0.1666667 * temp) + (0.075 * temp * temp));
sonne_elevation = 57.29577951 * sonne_elevation;
real nenner = (sin_phi*cos_tau) - (cos_phi * tan_delta);
if (nenner < 0.0) {boolean plus180 = true;}
real tan_azimut = sin_tau / nenner;
!##### berechnung sonne_azimut mit stueckweiser linearisierung des arctan ############
boolean vorzeichen = true;
if (tan_azimut < 0.0) {vorzeichen = false; tan_azimut = (-1.0)*tan_azimut;}
real sonne_azimut = 0.97723 * tan_azimut;
if ((tan_azimut >=0.2679)&&(tan_azimut < 0.5774)) {sonne_azimut = (0.84588* tan_azimut) + 0.035189;}
if ((tan_azimut >= 0.5774)&&(tan_azimut < 1.0)) {sonne_azimut = (0.6195* tan_azimut) + 0.1659;}
if ((tan_azimut >= 1.0)&&(tan_azimut < 1.3032)) {sonne_azimut = (0.43173* tan_azimut) + 0.3537;}
if ((tan_azimut >= 1.3032)&&(tan_azimut < 1.7321))  {sonne_azimut = (0.3052* tan_azimut) + 0.51856;}
if ((tan_azimut >= 1.7321)&&(tan_azimut < 2.4142)) {sonne_azimut = (0.1919* tan_azimut) + 0.7148;}
if ((tan_azimut >= 2.4142)&&(tan_azimut < 2.9459)) {sonne_azimut = (0.123* tan_azimut) + 0.88115;}
if ((tan_azimut >= 2.9459)&&(tan_azimut < 3.7321)) {sonne_azimut = (0.083312* tan_azimut) + 0.9981;}
if ((tan_azimut >= 3.7321)&&(tan_azimut < 5.0))  {sonne_azimut = (0.050792* tan_azimut) + 1.1194;}
if ((tan_azimut >= 5.0)&&(tan_azimut <7.0)) {sonne_azimut = (0.02775* tan_azimut) + 1.23465;}
if ((tan_azimut >= 7.0)&&(tan_azimut <12.0)) {sonne_azimut = (0.01175117* tan_azimut) + 1.346641;}
if ((tan_azimut >= 12.0)&&(tan_azimut <20.0)) {sonne_azimut = (0.004147854* tan_azimut) + 1.437881;}
if ((tan_azimut >= 20.0)&&(tan_azimut <50.0)) {sonne_azimut = (0.0009987* tan_azimut) + 1.5008639;}
if (tan_azimut >= 50.0) {sonne_azimut = (0.000099983* tan_azimut) + 1.54579974;}
if (sonne_azimut> 1.5707963278) {sonne_azimut = 1.5707963278;}
if (vorzeichen == false) {sonne_azimut = (-1.0) * sonne_azimut;}
sonne_azimut = 57.29577951 * sonne_azimut;
if (plus180 == true) {sonne_azimut = sonne_azimut + 180.0;}
!##### tageszeitliche korrektur und werte auf systemvariablen speichern ######
if (nachmittag == false)
{sonne_azimut = 180.0 - sonne_azimut; sonnenzeit = 720 - sonnenzeit;}
else
{sonne_azimut = sonne_azimut + 180.0;sonnenzeit = 720 + sonnenzeit;}
sonne_azimut = 0.1 *((sonne_azimut*10.0) .ToInteger());
sonne_elevation = 0.1 *((sonne_elevation*10.0) .ToInteger());
dom.GetObject("sonne_elevation").State(sonne_elevation);
dom.GetObject("sonne_azimut").State(sonne_azimut);

Ein sehr einfaches beispielhaftes WebUI-Programm zum Betätigen einer Rolllade ist hier:

Mit der Systemvariablen roll_AutoManuell wird die automatische Steuerung ein- und ausgeschaltet. Diese Systemvariable  kann mit einem weiteren WebUI-Programm und z.B. einer Fernbedienung ein- und ausgeschaltet werden. Die Möglichkeiten, mit Elevation und Azimut die Rollladen und Lampen eines Haus intelligent nach Licht und Schatten zu steuern, sind sehr vielfältig. Ich verweise hier auf mein Tutorial zur Rollladensteuerung.

Ach ja, zum Vergleich kann man die Daten mit einem „genauen“ Sonnenstandsrechner vergleichen: http://www.volker-quaschning.de/datserv/sunpos/index.php
Breiten und Längengrad eingeben und Berechnungsart „SUNAE“ wählen. Die Abweichungen sind bei mir meist unter einem Grad, was bei den verwendeten Näherungsverfahren für die trigonometrischen Funktionen ganz ordentlich ist. Für die Heimautomation ist das jedenfalls mehr als genau!

 

Ergänzung 14.03.2014

Wie man an den verwendeten Zahlenkolonnen im Skript erkennt, wurde bewusst weniger auf programmiertechnische „Schönheit“ ausgelegt, sondern vielmehr wurde auf möglichst wenig Rechenoperationen und damit Laufzeit optimiert. Dies ist deshalb wichtig, weil das Skript zyklisch häufig aufgerufen wird!
Geringe Unstetigkeiten im Verlauf des Elevations- und Azimutwinkels bedingt durch die verwendeten Näherungsverfahren wurden weiter optimiert, so dass jetzt für die Heimautomation mehr als ausreichende Genauigkeit der Sonnenkoordinaten erreicht wird. Insbesondere im Bereich des Nulldurchgangs der Elevation ist ein möglichst stetiger Winkelverlauf deshalb wichtig, weil die meisten Steuerungsaufgaben im Bereich der Dämmerung erfolgen und hier ein möglichst gleichmässiger stufenloser Verlauf von grossem Vorteil ist.
Das folgende Bild zeigt sehr schön den Azimut und die Elevation, aufgezeichnet mit Historian über 24h. Diese Kurve verschieben sich täglich um einen geringen Betrag, wie man an dem geringen Sprung in der Elevationskurve um ca 00:00h erkennt:

sonnenstand1

Genauigkeit

Der Vergleich mit Winkelergebnissen der Internet-Sonnenpositionsrechner ist abhängig von dem dort verwendeten Berechnungsverfahren:
Bei dem Berechnungsverfahren SUNAE war der Unterschied bei der Elevation meist weniger als ein halbes Grad. Der Azimutwinkel hatte Abweichungen bis zu etwa 2 Grad. Letztlich ist aber nicht die Genauigkeit entscheidend, sondern dass man im Bereich des Sonnenauf- und -untergangs mit dem Elevationswinkel eine gur aufgelöste stufenlose Zahl hat, von der man Schaltvorgänge reproduzierbar abhängig machen kann. Mit dem Azimut steuert man in der Regel sowieso nur Beschattungseinrichtungen, bei denen eine Winkelgenauigkeit von 2Grad mehr als genau sind.

 

Update 07.04.2016:

Alternatives Skript mit weniger verwendeter Systemvariablen

Vermutlich kann die CCU nur eine begrenzte Zahl von Namen in Skripten stabil verarbeiten. (man spricht von 200 ?!). Deshalb wurde das Sonnenstand-Skript diesbezüglich weiter optimiert, so daß beim nachfolgenden verbesserten Skript nur noch 11 Variablen verwendet werden. Allerdings ist die Lesbarkeit das Verständnis des Programmes dabei verloren gegangen. Aber man kann sich ja dafür das erste Listing ansehen, welches die gleiche Funktion allerdings mit deutlich mehr Variablennamen hat.

!berechnung sonne_elevation, sonne_azimut; stand 07.08.2016  verfasser: eugen stall,  stall.biz
!Zwei Systemvariablen anlegen:
!sonne_elevation  mit Variablentyp Zahl von -180 bis +180 grad
!sonne_azimut mit Variablentyp Zahl von-360 bis +360 grad
!dieses skript alle 4min aufrufen 
real temp;
real sin_phi;
real cos_phi;
integer sonnenzeit;
boolean nachmittag;
real sin_tau;
real cos_tau;
real tau1;
real sin_delta;
real cos_delta;
boolean vorzeichen;
 
integer temp = system.Date("%M").ToInteger() + 60*system.Date("%H").ToInteger();
integer sonnenzeit =temp + 720 - 0.5 *((system.SunriseTime("%M").ToInteger() + 60*system.SunriseTime("%H").ToInteger()) +system.SunsetTime("%M").ToInteger() + 60* system.SunsetTime("%H").ToInteger());
if (sonnenzeit > 1440) {sonnenzeit = sonnenzeit -1440;}
if (sonnenzeit < 1) {sonnenzeit = 1440 + sonnenzeit;}
if (sonnenzeit > 720) {sonnenzeit =sonnenzeit - 720; nachmittag = true; }
   else {sonnenzeit =720 -sonnenzeit;nachmittag =false;}
temp = 0.00436332313 * sonnenzeit;   
if (temp < 1.570796327)
  {real sin_tau =temp * ((temp * temp * temp * temp *  0.0083334) +1.0 - (temp * temp *0.1666667));
   temp= 1.570796327 - temp;
   cos_tau =temp * ((temp * temp * temp * temp *  0.0083334) +1.0 - (temp * temp * 0.1666667));}                   
   else {real tau1  =3.141592654 - temp;
         sin_tau =tau1 * ((tau1 * tau1 * tau1 * tau1 *  0.0083334) +1.0 - (tau1 * tau1 * 0.1666667));
         temp = temp  -  1.570796327;
         real cos_tau = (temp) *(-1.0)* ((temp * temp * temp * temp *  0.0083334) +1.0 - (temp * temp * 0.1666667));}
temp = system.Date("%j").ToInteger() +10;
if (temp > 365) {temp = temp - 365;}
if (temp < 92) {real tag = 0.0172142 *temp;
                tau1 = (-0.410152) *((tag * tag *tag * tag *0.041666)  + 1.0 - (tag * tag * 0.5));}
if ((temp >91) && (temp < 184)) {temp = 183 - temp; real tag = 0.0172142 *temp;
                                 tau1 = (0.410152) *((tag * tag *tag * tag *0.041666)  + 1.0 - (tag * tag * 0.5));}
if ((temp >183) && (temp < 275)) {temp = temp - 183; real tag = 0.0172142 *temp;
                                  tau1 = (0.410152) *((tag * tag *tag * tag *0.041666)  + 1.0 - (tag * tag * 0.5));}
if ((temp >274) && (temp < 366)) {temp = 365 - temp; real tag = 0.0172142 *temp;
                                  tau1 = (-0.410152) *((tag * tag *tag * tag *0.041666)  + 1.0 - (tag * tag * 0.5));}
sin_delta =tau1 * ((tau1 * tau1 * tau1 * tau1 *  0.0083334) +1.0 - (tau1 * tau1 * 0.1666667)); !sinus-naeherung
cos_delta = (tau1 * tau1 * tau1 * tau1 *0.0416667)  + 1.0 - (tau1 * tau1 * 0.5); !cosinus-naeherung
if (tau1 < 0.0) {vorzeichen = false; tau1 = (-1.0) * tau1;} else {vorzeichen = true;}
temp = 0.017453292*system.Latitude(); 
sin_phi =(temp * ((temp * temp * temp * temp * 0.0083334) +1.0 - (temp * temp * 0.1666667)));
cos_phi = ((temp * temp *temp * temp *0.0416667)  + 1.0 - (temp * temp * 0.5));
temp = (sin_phi * sin_delta) +( cos_phi * cos_delta * cos_tau);
temp = temp * (1.0 + (0.1666667 * temp * temp) + (0.075 * temp * temp * temp * temp));     
temp = 57.29577951 * temp;
temp= 0.1 *((temp *10.0) .ToInteger());     
dom.GetObject("sonne_elevation").State(temp);
WriteLine(temp);
 
if (tau1 >=0.2618) {tau1 = (1.1822 * tau1) - 0.0416;}else {tau1 = 1.0233 * tau1;}
if (vorzeichen == false) {tau1 = (-1.0) * tau1;}
temp = (sin_phi*cos_tau) - (cos_phi * tau1);
if (temp < 0.0) {boolean plus180 = true;}  
temp = sin_tau / temp;
vorzeichen = true;
if (temp < 0.0) {vorzeichen = false; temp = (-1.0)*temp;}
tau1 = 0.97723 * temp;
if ((temp >= 0.2679)&&(temp < 0.5774)) {tau1 = (0.84588* temp) + 0.035189;}
if ((temp >= 0.5774)&&(temp < 1.0)) {tau1 = (0.6195* temp) + 0.1659;}
if ((temp >= 1.0)&&(temp < 1.3032)) {tau1 = (0.43173* temp) + 0.3537;}
if ((temp >= 1.3032)&&(temp < 1.7321))  {tau1 = (0.3052* temp) + 0.51856;}
if ((temp >= 1.7321)&&(temp < 2.4142)) {tau1 = (0.1919* temp) + 0.7148;}
if ((temp >= 2.4142)&&(temp < 2.9459)) {tau1 = (0.123* temp) + 0.88115;}
if ((temp >= 2.9459)&&(temp < 3.7321)) {tau1 = (0.083312* temp) + 0.9981;}
if ((temp >= 3.7321)&&(temp < 5.0))  {tau1 = (0.050792* temp) + 1.1194;}
if ((temp >= 5.0)&&(temp <7.0)) {tau1 = (0.02775* temp) + 1.23465;}
if ((temp >= 7.0)&&(temp <12.0)) {tau1 = (0.01175117*temp) + 1.346641;}
if ((temp >= 12.0)&&(temp <20.0)) {tau1 = (0.004147854* temp) + 1.437881;}
if ((temp >= 20.0)&&(temp <50.0)) {tau1 = (0.0009987*temp) + 1.5008639;}
if (temp >= 50.0) {tau1 = (0.000099983* temp) + 1.54579974;}
if (tau1> 1.5707963278) {tau1 = 1.5707963278;}
if (vorzeichen == false) {tau1 = (-1.0) * tau1;}
tau1 = 57.29577951 * tau1;
if (plus180 == true) {tau1 = tau1 + 180.0;}
if (nachmittag == false)
  {tau1 = 180.0 - tau1; sonnenzeit = 720 - sonnenzeit;}
   else {tau1 = tau1 + 180.0;sonnenzeit = 720 + sonnenzeit;}
tau1 = 0.1 *((tau1*10.0) .ToInteger());
dom.GetObject("sonne_azimut").State(tau1);
WriteLine(tau1);

35 Kommentare

  1. Ich benutze noch 2.29.23 im „Standard“-CCU-Modus und habe keinerlei Probleme. Aber im anderen Modus könnten vielleicht Kompatibilitätsprobleme auftauchen.
    Hab ich aber nicht geprüft!

  2. Moinsen,
    nutze dieses ausgezeichnete Script (2016er-Version), seit ich vor einem knappen Jahr in die homemtic-Steuerung eingestiegen bin – Danke dafür!
    Es ist genau dass, wonach ich länger gesucht hatte.
    Seit gestern zickt es nun ein wenig … seit ich die CCU2-Software auf die Version 2.31.25 aktualisiert habe!
    Zwischen 18:30 Uhr & 21:00 Uhr errechnet das Script (wie empfohlen mit der praktikablen Aktualisierung von 4 min) gelegentlich (2 – 3 mal im genannten Zeitraum) elevation-Werte von um die 21; obwohl diese tatsächlich zwischen -7.0 & – 18 liegen müßten; wo sie mit der nächsten Neuberechnung dann auch wieder zu finden sind.
    Logischerweise fahren dann alle über dieses Script gesteuerten Rolläden zunächst einmal hoch … bis durch die folgende, korrekte Aktualiserung des Wertes eine Änderung erzeugt wird, welche das erneute Absenken der Rolläden bewirkt.
    Zwischenzeitlich versuchte ich dieses Verhalten durch die Löschnung, & anschließender Neueingabe aller Rolladen-, sowie des Sonnestandsberechnungsprogramms zu eliminieren: erfolglos!
    Testweise habe ich jetzt das 2014er-Script eingespielt; mal sehen, was nun passiert.
    Ist dieses Scriptverhalten unter der Version 2.31.25 schon bekannt, oder tritt es isolierte auf meiner CCU2 auf?
    Da ich mich nicht im geringsten mit der Erstellung von Scripten auskenne, darf ich diese Frage einmal an den Verfasser stellen.

    Beste Grüße,
    Jojo

  3. Hallo

    danke für das Script, ich werde es demnächst ausprobieren. Hat schon mal jemand die Steuerung mit den neuen Jalousieschaltern ausprobiert? Dort kann man ja die Lamellenposition festlegen, das wäre mit dem Script hier zusammen ein guter Weg für eine Beschattung.

  4. Noch ein kleiner Hinweis an alle die mit der HM-Zeitsteuerung Probleme haben.
    Ich habe mir einfach einen Außentemperatursensor angeschafft. Dieser aktualisiert, eine Systemvariable _TICKER bei jedem Datenupdate (alle 180-300sek glaube ich).
    Und die Änderung bei Ticker löst dann alle Zeitgesteuerten Programme aus.
    So werden die zyklen vermieden die durch die Zeitsteuerung entstehen, da auf ein Push-Ereignis reagiert wird. Seit dem laufen bei mir alle Skripte sehr zuverlässig

  5. Das liegt definitiv nicht an diesem erprobten HM-Skript, das regelmäßig mit der CCU-Zeitsteuerung ausgelöst wird.
    Die Ursache ist wahrscheinlich die aktuell immer noch unzuverlässige Funktion der CCU-Zeitsteuerung gerade bei kleinen Zeiten, auf die in vielen Posts im Homematic-Forum schon oft hingewiesen wurde.
    Die Lösung ist die Verwendung des CUxD-Timers oder Warten auf die nächste CCU-Firmware, bei der dieser Bug vermutlich /hoffentlich behoben ist.
    Hier steht mehr dazu!

  6. Hallo,

    ich habe das Skript am laufen. Es rechnet sehr genau. Klasse. Leider hört es nachts irgendwann auf zu aktualisieren. Das gilt für das Skript mit vielen Systemvariablen und ebenso für das Skript mit optimierten Systemvariablen. Hat jemand eine Idee, woran das liegen könnte?

  7. Oh Sorry, war mein Fehler. Die Variablen wurdn nicht aktuallisiert und haben enen Stand von gestern angezeigt.

    Danke!

  8. Komischerweise zeigt meine Systemvariable „sonne_azimut“ einen Unterschied von 60 Grad zur realität.

    ???

  9. Private Nutzung ist mitversichert

  10. Hallo,
    ich habe gerade die aktuellste Version in mein Programm kopiert,
    aber mein Raspberrymatic bringt nur Fehler.
    Läuft irgendwie nicht…

  11. … hab mal ein einfaches beispielhaftes WebUI-Programm in den Thread eingestellt.

  12. Beschäftige mich neu mit dem Thema. Deshalb vielleicht die komisch anmutende Frage, welchen Wert oder welche Werte ich dann für Sonnenauf- bzw Sonnenuntergang eintragen muß für die Rolladensteuerung? Genügt der Azimut Wert oder muß ich immer beide Werte berücksichtigen (Azimut und Elevation)? Wäre schön wenn jemand ein Beispiel einer Rolladensteuerung einstellen könnte

  13. Hallo,

    ich habe das faszinierende Script gerade auf meine CCU gebracht. Leider komme ich trotz sehr genauer Positionsdaten auf große Unterschiede beim Vergleich mit den Werten von volker-quaschning.de (Azimut ist bei mit ~14° kleiner und Elevation ~4° größer).

    Was mache ich falsch?

  14. Wie muss den das WebUI-Programm dazu aussehen???

  15. Hallo „Funkleuchtturm“ ,

    vielen Dank für die Info und das hervorragende Script !
    Ich habe nun auch die dazugehörigen Beiträge im HomeMatic-Forum gefunden, und Anregungen dazu gesammelt.
    Das Script läuft nun sein einer Woche zur vollsten Zufriedenheit.

    Nochmal vielen Dank dass Du Deine Arbeit dem Forum zur Verfügung gestellt hast.

    MFG
    Peter

  16. Eine Anpassung von Sommer- und Winterzeit muß nicht erfolgen, weil im Skript eine sog. Sonnenzeit berechnet wird. Diese Sonnenzeit bestimmt sich u.a. aus den aktuellen Sonnenaufgangs- und Sonnenuntergangszeiten. Du schaust dazu am besten in da Skript-Listing.

  17. Hallo, ich noch mal !
    Habe die Werte aus dem Script mal mit dem „genauen“ Sonnenstandsrechner von „Volker-Quaschning“ verglichen.
    Ich muss sagen die Ergebnisse sind fast identisch !

    Habe die Werte auch mal mit dem Excel-Diagramm von „Friedhelm-Maßong“ verglichen (Ein Hinweis von Dir im anderen Sonnenstandsprogramm)
    Da muss ich allerdings feststellen, dass die Werte auch fast identisch sind aber um exakt 1Std. voneinander abweichen.

    Deshalb meine Frage: Sind die Werte die das Script liefert immer exakt der aktuellen Uhrzeit (Sommer und Winterzeit) oder muss im Script eine Anpassung erfolgen ?

    Mit freundlichen Grüßen
    Peter

  18. Hallo,
    bin als HomeMatic Neuling kürzlich auf der Suche nach Lösungen für meine Rollosteuerung auf ihre website gestoßen.
    Vielen Dank für die vielen wunderbaren „Kochrezepte“ !

    Das Script für die Sonnenstandsberechnung und ein entsprechendes Programm zum Start der kontinuierlichen Berechnung habe ich eingerichtet und es werden auch „vermutlich“ richtige Werte geliefert..

    Nur leider kann ich mit den Werten zur Verwendung in meiner geplanten Rollosteuerung nichts anfangen.

    Könnten Sie mir mit einem Beispielprogramm für „Rollo runter x-Minuten nach SU“ und „Rollo rauf x-Minuten nach SA“ behilflich sein.

    Vielen Dank schon mal im voraus.
    MFG Peter

  19. Guten Abend

    Danke für das tolle Skript bin Neuling in Sachen HM und möchte gern meine Rolläden damit Steuern. Ich wäre für ein Beispiel sehr Dankbar.

    Einen schönen Abend und LG

  20. … das Skript läuft eigentlich sehr stabil, weil keine für Instabilitäten bekannte system.Exec-Aufrufe verwendet werden. Habe bezüglich Stabilität bisher keine negativen Rückmeldungen. Wichtig ist, das Skript nicht zu schnell hintereinander aufzurufen: ich denke alle 4 Minuten ist o.k.

  21. Hallo admin,
    habe das Programm jetzt seit einer Woche bei mir auf der CCU2 am laufen.
    Mir ist nur zweimal aufgefallen das sich in der Nacht nur das Programm weg hängt, die anderen Programme laufen weiter. Habe die Programmstarts beim ersten Mal schon um 10s verzögert gestartet. Aber daran kann das woll nicht Ligen da es wieder passiert ist.
    Gibt es bei mir nur die Probleme oder ist das bekannt?
    Das Programm von der Funktion her finde ich einfach super!

  22. … wenn man erst mal versteht, daß viele Dinge des täglichen Lebens (nicht nur die Rolläden 😉 im Winter anders getaktet sind als im Sommer, dann kann man den Nutzen einer Sonnenstand-Information zur Steuerung der Hausautomation gar nicht hoch genug einschätzen. Seitdem ich die Sonnenstandsinformation in meine Steuerungen eingebaut habe, benötige ich eigentlich keine Fernbedienungen mehr.
    … und genau so möchte ich es haben, weil intelligente Automation ohne Fernbedienung auskommen muß!!

  23. Historian läuft nicht auf der CCU sondern auf einem PC im Heimnetz. Der muß natürlich zum Loggen dauernd laufen. Die Anleitung für die Installation von Historioan ist hier: http://homematic-forum.de/forum/viewtopic.php?f=38&t=6021#p39548
    Damit kann man dann alle Variablen loggen und auch nachträglich beliebige Variablen ausfiltern. Ich finde das sehr gut, um nach Fehlern zu suchen oder z.B. die Heizung zu optimieren etc.!

  24. Vielen vielen Dank für das Skript un die zusätzlichen Informationen! Sehr nützlich das Ganze.

  25. Wie haben Sie das mit CCU-Historian gelöst?
    Historian läuft doch nicht auf der CCU oder kann man Historian genauso instalieren wie CUxD als Zusatzsoftware?

  26. Hallo,
    auch erst mal danke für das tolle Skript.
    Ich möchte die beiden Systemvariablen gerne in in CUxD mit loggen.
    Könnten Sie mir eventuell sagen wie ich das mache?
    Mit LOGIT= geht das wohl nicht, ich habe ja nur den Namen und sonst nichts.

  27. Hallo HP,
    das ist wie beim Kochen: wenn es allen geschmeckt hat, dann ist es für den Koch Belohnung genug!
    Freue mich über die positive Rückmeldung 🙂

  28. Hallo,
    danke, dass Du dieses tolle Skript und damit Deine Arbeit uns allen zur Verfügung stellst.

    Ich habe gerade mit HM angefangen und war mit sunset/sunrise zur Rolladensteuerung total unzufrieden. Meine Überlegungen gingen über verschiedene Stationen unterschiedlicher Genauigkeit und Flexibilität zum Theme Analemma.

    Dann habe ich recherchiert und praktisch sofort Dein Skript gefunden. Dank Deiner kurzen aber präzisen Anleitung konnte ich mit fast Null HM-Wissen das Problem innerhalb von 10 Minuten lösen.

    BEGEISTERUNG: Tolle, praxisgerechte Lösung! GANZ, GANZ GROSSES DANKE!!!

  29. … wahrscheinlich fehlt bei „ganztägig“ das entsprechende Häkchen!

  30. Danke für das tolle Skript. Ich habe bei mir an der CCU2 nur das Problem, dass es nicht automatisch getriggert wird, sondern nur manuell. Ich habe ein Programm das:
    Wenn -> Zeitsteuerung (Zeitpunkt 00:00h ; Zeitintervall Alle 5 Minuten ; Kein Enddatum) -> zu Zeitpunkten auslösen
    Dann -> Skript (siehe Oben) -> sofort

    Die Variablen werden aber nicht automatisch aktualisiert, sondern nur wenn ich das Programm von Hand starte. Irgendeine Idee?

  31. … Du mußt in der Homematic für Deine Standort die genauen Breiten und Längeneingaben machen. Das Skript holt sich diese Daten aus den HM-Einstellungen.
    Die Genauigkeit des Azimut ist in der Regel so um die 1°. Weitere Abweichungen mit anderen Berechnungsarten können durch die verschiedenen Dämmerungsdefinitionen entstehen (siehe Wikipedia).

  32. Hallo,

    genau nach diesem Script haben ich schon lange gesucht.

    Leider wird beim Überprüfen der mit der Webseite http://www.volker-quaschning.de/datserv/sunpos/index.php andere Daten ausgegeben.

    Die Angabe Azimut weicht gerundet um ganze 14° ab.

    Die Breitengrad-Angaben habe ich bereits überprüft. Diese stimmen überein. Was mich etwas verwundert ist, dass die Längenangabe im Script nicht abgefragt wird, während diese Auf der Vergleichswebseite angegeben werden muss.

    Wo kann die Differenz zustande kommen?

  33. Hallo,
    Wenn du beispielsweise dämmerungsabhängig die Beleuchtung einschalten möchtest und zu einer festen Zeit (z.B. 23h) wieder ausschalten möchtest, dann ist Dein WebUI-Programm ganz einfach:

    wenn
    systemvariable sonne_elevation < -6.5 bei Änderung auslösen
    UND
    Zeitsteuerung täglich von 16:00 bis 23:00 zu Zeitpunkten auslösen
    dann
    lampe sofort Schaltzustand EIN
    sonst
    lampe sofort Schaltzustand aus

    oder eine andere Lösung, wenn die Lampen z.B. nur zwei Stunden nach dem dämmerungsabhängigen Einschalten brennen sollen:

    wenn
    systemvariable sonne_elevation < -6.5 bei Änderung auslösen
    dann<
    lampe sofort Schaltzustand EIN
    lampe verzögert um 2h Schaltzustand aus

    oder eine weitere Lösung , wenn die Lampen abends am Ende der Dämmerung angehen sollen und morgens vor Sonnenaufgang ausgehen sollen.

    wenn
    systemvariable sonne_elevation < -3.0 bei Änderung auslösen
    dann
    lampe sofort Schaltzustand EIN
    sonst
    lampe sofort Schaltzustand aus

    Da gibt es noch viele mögliche andere Lösungen, ganz nach Deinem Bedarf!

  34. Moin Moin,

    habe heute deine Homepage gefunden und muss sagen bin begeistert. Zur Zeit steuere ich einige Lampen über ein Tageszeit Script (Nacht;Frühmorgens;Morgengrauen;Vormittag;Mittag;Nachmittag;Dämmerung;Abend;) was aber im Sommer einige Nachteile mit sich bringt. In der Woche soll das Licht im Flur z.B. um 22:30Uhr ausgehen. Nach der Tageszeitberechnung ist aber noch Abends und somit geht das Licht wieder an.

    Mit diesem Script würde das perfekt funktionieren.

    Jedoch stehe ich auf dem Schlauch wie ich was eintragen muss.

    Magst du mir helfen??

    Mit freundlichen Grüßen!
    Mathias

Trackbacks/Pingbacks

  1. Windwächter: Erweiterte Programierung – dax.la - […] Voraussetzung für mein Programm ist ein Script, welches den Sonnenstand (Azimute und Elevation) berechnet. Hierzu verlinke ich einfach mal…

Kommentar absenden

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Translate »