Dämmerungsscript

[dzvo]

Was mich interessieren würde ... Wann werden die Daten bei dir aktualisiert?

Gruß
Dzvo


Gesendet von meinem iPad mit Tapatalk HD

[AJRaven]

Hallo Alle,

ich versuche nun schon seit einigen Stunden das Dämmerungsskript bei mir ans Laufen zu bringen, scheitere aber daran, dass alle Anleitungen, die ich finden konnte, hoffnungslos veraltet zu sein scheinen und einige der alten Links auch nicht mehr funktionieren. Dazu kommt, dass scheinbar auch einige Tweeks vorzunehmen sind um das Ganze auf der CCU2 ans laufen zu bringen. Kann mir hier jemand sagen, wo ich eine aktuelle Anleitung finde?
und wo ich die letzte Version des Skripts finde? (hier ist ja scheints auch einiges verbessert und nachgebessert worden).

Konkret habe ich folgende Probleme:
- das lcd:msg Skript, dass ich gefunden habe enthält keine demonize.tcl - eine andere Version konnte ich nicht finden.
- http://www.homematic-wiki.info/mw/index ... 8;twilight verweist auf eine Seite, die nur entfernt etwas mit homematic zu tun hat
- ich konnte nicht finden, ob ich variablen anlegen muss und welche
- scheinbar muss man das skript nur einmal starten. Wie mache ich das, wenn nicht aus einem homematic Skript heraus?

In jedem Fall vielen Dank

[grmpf]

Hier das bei mir laufende twilight.tcl

Für die Wetterabfrage habe ich die wunderground.com eingebaut da Google irgendwann nicht mehr funktionierte. Am besten suchst du über den wunuderground link eine Wetterstation in Deiner Nähe und passt die Zeile dann an. Ebenfalls auf wunderground.com erhälst du einen KEY damit Du mit der API dort abfragen kannst.

ZEILE set url http://api.wunderground.com/api/KEY/con ... ny/ORT.xml <- ORT ersetzen! KEY ersetzen

Variablen:
Dämmerung (Werteliste)
Nacht;Aufgang Astronomisch;Aufgang Nautisch;Aufgang Bürgerlich;Aufgang;Aufgang Indoor;Aufgang Wetterabhängig;Untergang Wetterabhängig;Untergang Indoor;Untergang;Untergang Bürgerlich;Untergang Nautisch;Untergang Astronomisch

Dämmerungszeiten (Zeichenkette)

Tageslicht (Zahl, Wertebereich 0 bis 6)

Ich starte das twilight einmal wenn die CCU hochfährt (nach 2 Minuten). Da es ab und zu (sehr selten) mal verschwindet, frage ich mittags um 12 ab, ob Tageslicht < 6 ist oder um 22:30 > 3. Wenn das zutrifft starte ich die twilight nochmal.

Code: Alles auswählen

#!/bin/tclsh
#Version 1.5 mod by rmeyerz (calcTwilightTimes)
#param 0 = Breitengrad (nördlich)
#param 1 = Längengrad (östlich)
#param 2 = künstlicher Horizont
#param 3 = PLZ

#only run once, check if locking port 60 is opened
if {[catch {socket -server unknown -myaddr 127.0.0.1 60} locksock]} then {
  exit 0
}

source /usr/local/addons/twilight/daemonize.tcl

load tclrega.so

proc showTime x {
  if {$x && $x != 2000000000} then {
    clock format $x -format "%H:%M:%S"
  } else {
    return "--:--:--"
  }
}

proc log x {
  puts $::logfile "[showTime [clock seconds]]: $x"
  flush $::logfile
}

#define constants for the list access to make review easier
set NIGHT 0
set SR_ASTRONOMICAL 1
set SR_NAUTICAL 2
set SR_CIVIL 3
set SR_SUNRISE 4
set SR_INDOOR 5
set SR_WEATHER 6
set SS_WEATHER 7
set SS_INDOOR 8
set SS_SUNRISE 9
set SS_CIVIL 10
set SS_NAUTICAL 11
set SS_ASTRONOMICAL 12

proc getTimeDiff {dayofyear} {
  return [expr {-0.171*sin(0.0337 * $dayofyear + 0.465) - 0.1299*sin(0.01787 * $dayofyear - 0.168)}]
}

#
#modifizierter Teil w/ nicht vorh. astronomischer Dämmerung ab Ende Mai von rmeyerz
#
    proc calcTwilightTimes {latitude longitude timezone dayofyear horizon sunrisevar sunsetvar} {
      upvar $sunrisevar sunrise
      upvar $sunsetvar sunset

      set timediff [expr {-0.171*sin(0.0337 * $dayofyear + 0.465) - 0.1299*sin(0.01787 * $dayofyear - 0.168)}]
      set declination [expr {0.4095 * sin(0.016906 * ($dayofyear - 80.086) ) }]

          set acosvar [expr ((sin($horizon/57.29578) - sin($latitude/57.29578)*sin($declination)) / (cos($latitude/57.29578)*cos($declination)))]

    #Falls der acos-Wert kleiner als -1 ist werden künstliche Werte genommen
    if {$horizon == -18
       && $acosvar < -1} then {
    set acosvar [format "%.3f" $acosvar]


    #      jetzt werden den Variablen auf Basis von Mitternacht und der Startzeit von 01.15 Uhr
    #      die Werte für den nächsten Sonnenaufgang 1,5 Stunden nach Mitternacht und des nächsten Sonnenuntergangs 25 Stunden nach Mitternacht
    #      des aktuellen Tages zugeordnet

    set sunset [expr {[clock scan "0 + 25 hours"]}]
    set sunrise [expr {[clock scan "0 + 90 min"]}]

    set Untergang [clock format $sunset -format "%d.%m.%Y %T"]
    set Aufgang [clock format $sunrise -format "%d.%m.%Y %T"]

    log "Die Variable acosvar beträgt momentan $acosvar  und liegt somit außerhalb des Wertebereiches"
    log "Der astronomische Aufgang wurde auf den $Aufgang gesetzt"
    log "Der astronomische Untergang wurde auf den $Untergang gesetzt"


    } else {
      set suntime [expr {12*acos($acosvar)/3.141592}]
      set sunrise [expr {[clock scan "0"] + round((12 - $timediff - $suntime - $longitude/15.0 + $timezone)*3600)}]
      set sunset  [expr {[clock scan "0"] + round((12 - $timediff + $suntime - $longitude/15.0 + $timezone)*3600)}]
    }
    }

#
#modifizierter Teil w/ GOOGLE Wetterdienstabdankung. Jetzt wunderground.com
#
proc getTwilightHorizon {base_horizon} {
  set url http://api.wunderground.com/api/KEY/conditions/lang:DL/q/germany/ORT.xml
  set twilightHorizon 5.0
    exec /usr/bin/wget -q -O /tmp/twilightweather.xml $url
    set f [open "/tmp/twilightweather.xml"]
    set input [read $f]
    close $f

regexp "<current_observation>(.*?)</current_observation>" $input dummy current  ; #get current observation
regexp "<weather>(.*?)</weather>" $current dummy weather  ; #get current weather

     log "current condition is \"$weather\""
     file delete /tmp/twilightweather.xml

   switch $weather {
      "Klar"              {set twilightHorizon [expr {$base_horizon + 0.2}]}
      "Meist sonnig"      {set twilightHorizon [expr {$base_horizon + 1.0}]}
      "Teils sonnig"      {set twilightHorizon [expr {$base_horizon + 1.7}]}
      "Heiter"            {set twilightHorizon [expr {$base_horizon + 1.8}]}
      "Wolkig"            {set twilightHorizon [expr {$base_horizon + 1.9}]}
      "Meistens bewölkt"  {set twilightHorizon [expr {$base_horizon + 2.0}]}
      "Leichtes Nieseln"  {set twilightHorizon [expr {$base_horizon + 4.0}]}
    }
  log "twilight horizon set to $twilightHorizon"
  return $twilightHorizon
}

proc getDayOfYear {timestamp} {
  set dayofyear [string trimleft [clock format $timestamp -format "%j"] "0"]
  #subtract the fractional part to the next leap-year february 29th from the current day of the year
  set dayofyear [expr {$dayofyear - ([clock format $timestamp -format "%Y"]%4)/4.0 - ($dayofyear)/365.25/4.0}]
  return $dayofyear
}

proc waitToTime {logfile destTime} {
  set waittime [expr {1000*($destTime - [clock seconds])}]
  if {$waittime > 0} then {
    log "waiting [expr $waittime/1000] s until [clock format $destTime]"
    #after is off of several seconds (exactly 1/1000?) after long waits, so wait 1% shorter and then wait again
    after [expr { 990*($destTime - [clock seconds])}]
    after [expr {1000*($destTime - [clock seconds])}]
  } else {
    log "not waiting [expr $waittime/1000] s until [clock format $destTime]"
  }
}

proc displayValues {} {
  uplevel {
    set display "s. folgende Tabelle vom [clock format [lindex $twilight_times 6] -format "%d.%m."]"
    append display "</div><br/><table border=\"1\" bordercolor=\"#000000\" style=\"background-color:#5d6373\" width=\"100%\">\r\n"
    append display "<tr><td><b>Dämmerung</b></td><td><b>Morgens</b></td><td><b>Abends</b></td></tr>\r\n"
    for {set j 1} {$j <= 6} {incr j} {

      set insert "[lindex $twilight_descr $j]:"
      if {$j == $i || $j == 12-$i} then {set insert "<b>$insert</b>"}
      append display "<tr><td>$insert</td>"

      set insert "[showTime [lindex $twilight_times [expr $j-1]]]"
      if {$j == $i} then {set insert "<b>$insert</b>"}
      if {$j == 6 && !$srw_set} then {set insert "<i>$insert</i>"}
      append display "<td>$insert</td>"

      set insert "[showTime [lindex $twilight_times [expr 12-$j]]]"
      if {$j == 13-$i} then {set insert "<b>$insert</b>"}
      if {$j == 6 && !$ssw_set} then {set insert "<i>$insert</i>"}
      append display "<td>$insert</td></tr>\r\n"
      #log "updating twilight time table: [showTime [lindex $twilight_times [expr $j-1]]] [showTime [lindex $twilight_times [expr 12-$j]]] [string map {: { }} [lindex $twilight_descr [expr $j-1]]]"
    }
    append display "</table></td>"
    rega_script "dom.GetObject('Dämmerungszeiten').State('$display');"
  }
}

#
# Main execution
#

set latitude [lindex $argv 0]
set longitude [lindex $argv 1]
set indoor_horizon [lindex $argv 2]
set plz [lindex $argv 3]

#some vars we need
set horizon_values [list 0 -18 -12 -6 [expr {- 50.0 / 60.0}] $indoor_horizon [expr {$indoor_horizon + 5.1}]]
set twilight_names [list night astronomical nautical civil standard indoor weather]
set twilight_descr [list Nacht Astronom. Nautisch Bürgerlich Standard Indoor Wetterabh.]

while {1} {
  set timezone [expr {([clock scan "0 UTC"] - [clock scan "0"]) / 3600.0}]
  set now [clock seconds]
  set twilight_midnight [expr {[clock scan "0"] + round((0 - [getTimeDiff [getDayOfYear $now]] - $longitude/15.0 + $timezone)*3600)}]

  #get the day of the year as numeric value based on twilight midnight (time between midnight and twilight midnight belongs to day before)
  set yesterday_offset 0
  if {$now < $twilight_midnight} then {
    #use time table from day before
    set yesterday_offset 86400
  }
  set dayofyear [getDayOfYear [expr $now-$yesterday_offset]]

  catch {file delete "/tmp/twilight.[expr int($dayofyear)-3].log"}
  set logfile [open "/tmp/twilight.[expr int($dayofyear)].log" w]
  log "args: $argv"
  if {$now < $twilight_midnight} then {log "twilight midnight not reached, using yesterdays time table"}
  log "timezone: $timezone, twilight midnight: [showTime $twilight_midnight], dayofyear: $dayofyear"

  set twilight_times ""
  for {set i 1} {$i <= 6} {incr i} {
    calcTwilightTimes $latitude $longitude $timezone $dayofyear [lindex $horizon_values $i] sunrise_time sunset_time
    if {$sunrise_time == 0} then {
      log "no [lindex $twilight_names $i] twilight here and now"
    } elseif {$i != 6} then {
      log "calculated twilight times: sunrise [clock format $sunrise_time -format "%d., %H:%M:%S"], sunset [clock format $sunset_time -format "%d., %H:%M:%S"] for [lindex $twilight_names $i] ($i)"
    }
    #do not append weather sunrise
    if {$i != 6} then {
      lappend twilight_times [expr $sunrise_time-$yesterday_offset]
    }
    #append indoor sunrise again to replace weather sunrise
    if {$i == 5} then {
      lappend twilight_times [expr $sunrise_time-$yesterday_offset+1]
    }
    #always append sunset
    lappend twilight_times [expr $sunset_time-$yesterday_offset]
  }
  set twilight_times [lsort $twilight_times]
  log "calculated twilight times: sunrise [clock format [lindex $twilight_times 5] -format "%d., %H:%M:%S"], sunset [clock format [lindex $twilight_times 6] -format "%d., %H:%M:%S"] for [lindex $twilight_names 6] (6)"
  set srw_set 0
  set ssw_set 0
  displayValues

  #in the following calculation, assume that the weather sunrise and sunset are always subsequently on the current dayofyear
  for {set i 0} {$i < 12} {incr i} {
    set next_time [lindex $twilight_times $i]

    if {$i == 5 && [clock seconds] < [lindex $twilight_times 6]} then {
      #sunrise weather
      log "retrieving weather condition for sunrise"
      calcTwilightTimes $latitude $longitude $timezone $dayofyear [getTwilightHorizon $indoor_horizon] sunrise_weather dummy
      set next_time $sunrise_weather
      set srw_set 1
      set twilight_times [lreplace $twilight_times 5 5 $sunrise_weather]
      displayValues
      log "weather sunrise at [showTime $next_time]"
    }
    if {[clock seconds] < $next_time && $next_time != 2000000000} then {
      log "current twilight state $i ([lindex $twilight_descr [expr {6-abs($i-6)}]]), sunlight state [expr {6-abs($i-6)}], next at [showTime $next_time]"
      rega_script "dom.GetObject('Dämmerung').State('$i');"
      rega_script "dom.GetObject('Tageslicht').State('[expr {6-abs($i-6)}]');"
      displayValues
      waitToTime $logfile $next_time
    }
    if {$i == 6 && [clock seconds] < [lindex $twilight_times 7]} then {
      #sunset weather
      log "retrieving weather condition for sunset"
      calcTwilightTimes $latitude $longitude $timezone $dayofyear [getTwilightHorizon $indoor_horizon] dummy sunset_weather
      set next_time $sunset_weather
      set ssw_set 1
      set twilight_times [lreplace $twilight_times 6 6 $sunset_weather]
      displayValues
      log "weather sunset at [showTime $next_time]"
      waitToTime $logfile $next_time
    }
  }
  rega_script "dom.GetObject('Dämmerung').State('12');"
  rega_script "dom.GetObject('Tageslicht').State('0');"
  log "twilight cycle completed for day of year $dayofyear, waiting until twilight midnight for next run"
  waitToTime $logfile [expr {$twilight_midnight + 86400 - $yesterday_offset}]
  close $logfile
}

if {[file exists /var/run/twilight.tcl.pid]} then {
  catch {
    set f [open /var/run/twilight.tcl.pid]
    set filepid [read $f]
    close $f
    if {[pid] == $filepid} then {
      file delete /var/run/twilight.tcl.pid
    }
  }
}
close $locksock

und das daemonize.tcl

Code: Alles auswählen

set scriptname [lindex [file split $argv0] end]
if {[file exists /tmp/$scriptname.stop]} then {exit 0}

set daemonize 0
if {[file exists /tmp/$scriptname.pid]} then {
  catch {
    set f [open /tmp/$scriptname.pid]
    set filepid [read $f]
    close $f
    if {[pid] != $filepid} then {
      catch {exec kill $filepid}
      set daemonize 1
    }
  }
} else {
  set daemonize 1
}

if {$daemonize && ![regexp -- "-nodaemonize" $argv dummy]} then {
  eval exec /sbin/daemonize -p /tmp/$scriptname.pid -o /tmp/$scriptname.stdout -e /tmp/$scriptname.stderr /bin/tclsh $argv0 $argv
  exit 0
}

[AJRaven]

Super! Vielen Dank Gert. Läuft

Jetzt hab ich nur noch ein paar Fragen bezüglich der genauen Nutzung, bzw. Interpretation der Ausgabe:
- wie komme ich auf den Wert für den künstlichen Horizont, den ich übergeben muss? Bzw. gibt es eine sinnvolle Methode den "Indoor Horizon" zu bestimmen?
- wenn ich das Skript richtig verstehe liegt das Intervall für die wetterabhängige Zeit(6) immer innerhalb der indoor zeit (5), und diese innerhalb der standard zeit (4) usw..., richtig ?
- was sagt sunlight state aus?

[grmpf]

Schön das es läuft, dann hast Du schon gewonnen denn das ist eigentlich mein allerwichtigstes Skript und ich steuere darüber Außenbeleuchtung, Rollläden etc.!
Die Dämmerungsstufen bleiben immer in derselben Reihenfolge.
mit künstlichem Horizont und Indoor Horizon hab ich mich nie beschäftigt. Da war mal was wenn man in den Alpen in einem tiefen Tal wohnt - aber das tue ich nicht.
sunlight state sagt mir nichts.

[grmpf]

Seit heute früh Tageslichstufe 4 macht mein twilight.tcl keine updates mehr auf die Variablen - bzw. macht den Update immer nur mit denselben Werten. Dasselbe passiert auf der CCU2 eines Freundes! Hat irgendwer die gleichen Symptome?

[grmpf]

Ok - Fehler gefunden: Die in der wunderground-xml angesprochene Wetterstation existiert plötzlich nicht mehr. Habe nun eine andere eingetragen und es geht wieder reibungslos. Uff!

[rmeyerz]

Hallo,

auch nach vielen Jahren nutze ich immer noch gerne das Dämmerungsscript. Ich hatte ja einen kleinen Teil dazu beigetragen, dass das Problem mit der astronomischen Dämmerung behoben werden konnte.

Insgesamt läuft das Script gut. Allerdings stelle ich fest, dass hin und wieder einfach die Wetterwerte nicht richtig abgerufen werden. Das führt bei mir dazu, dass dann die Schaltzeiten (bspw. für die Gartenbeleuchtung) nicht ermittelt werden können und das Script einfach hängen bleibt. Das Script berechnet ja alle Werte bis auf den wetterabhängigen Wert unabhängig von einer Abfrage bei (momentan) wunderground. Noch einmal zur Erinnerung: Der Wetterabruf sorgt bspw. bei schlechtem Wetter dafür, dass sich die wetterabhängige Zeit Morgens nach hinter (später) und Abends nach vorne (früher) verschiebt. Macht ja auch Sinn. So würde bei grauem Wetter die Gartenbeleuchtung eben einen kleinen Moment früher angehen oder Morgens einfach noch ein paar Minuten weiter brennen.

Da aber gefühlt alle 2-4 Wochen das Script hängt und dann einfach nichts mehr geschaltet wird, schlage ich hier mal folgende Modifikation vor:
Das Script könnte so geändert werden, dass es unabhängig vom Wetterabruf wird. Also würde sich der zu errechnende Horizontwert nicht mehr zwischen 0,7 und 5 (oder so) befinden sondern auf einen Mittelwert gesetzt. Man bekäme dann sozusagen zum indoor Wert, der ja auch fest definiert ist, noch einen zweiten Wert, der aber nicht mehr variabel ist. Ehrlicherweise hatte ich nie das Gefühl, dass mir der Wetterabhängige Wert weitergeholfen hat.
Oder aber man baut eine Prüfung mit ein, die prüft, ob der Wetterwert ermittelt werden konnte und nach einer bestimmten Zeit (bei Nichtermittlung) dann einen vorgegeben Wert einsetzt.

Beide Modifikationen würden dazu führen, dass das Script einfach nicht mehr hängenbleibt. Ich denke, dies wäre eine sinnvolle Ergänzung.

Ich selber versuche gerade, die Variante mit der Wetterunabhängigkeit zu realisieren. Dazu mache ich folgendes: Der Programmteil gettwilighthorizon wird komplett entfernt. Dieser ermittelt einen wetterabhängigen Wert. Im Hauptteil des Programms definiere ich dann mit einer neuen Variable, der ich bspw. den Wert 3 gebe, genau diesen fehlenden Wert selber.

Bei folgenden Programmteilen ersetze ich dann folgendermaßen:

Code: Alles auswählen

# Main execution
#

set latitude [lindex $argv 0]
set longitude [lindex $argv 1]
set indoor_horizon [lindex $argv 2]
set plz [lindex $argv 3]
set wetter 3

also neue Variable "wetter" mit Wertzuweisung hier "3"

Code: Alles auswählen

 #sunrise weather
         calcTwilightTimes $latitude $longitude $timezone $dayofyear $wetter sunrise_weather dummy
      set next_time $sunrise_weather

und

Code: Alles auswählen

 #sunset weather
      log "retrieving weather condition for sunset"
      calcTwilightTimes $latitude $longitude $timezone $dayofyear $wetter dummy sunset_weather
      set next_time $sunset_weather

Hier wird die neue Variable "wetter" verwendet.

That's it. Lieber wäre mir eine Änderung mit der Prüfung, ob Wetterdaten abgerufen werden können. Vielleicht findet sich jemand.

[grmpf]

auch nach vielen Jahren nutze ich immer noch gerne das Dämmerungsscript

Für mich ist es schlicht DAS wichtigste Skript.

Das mit dem Hängenbleiben hatte ich auch schon beobachtet und bei mir folgenden Work-Around implementiert der eigentlich auch immer funzt:
Ich frage um 12 und 13 Uhr ab ob Tageslicht = 6 ist und wenn nicht, starte ich das skript nochmal. Um 13 Uhr kommt nur nochmal eine Kontrolle. Nachts mache ich dasselbe mit der Abfrage =0.
Ich wusste bisher nicht das dieser Fehler auch bei der Wetterabfrage liegt.

Da ich das Wetter meiner eigenen Wetterstation sowieso alle 15 Minuten von wunderground lese und die wichtigsten Werte in Variablen ablege habe ich jetzt vom direkten Aufruf von wunderground umgestellt auf die Abfrage meiner entsprechenden Systemvariablen Wetter-Bedingungen. Damit entfällt ein url-Aufruf der möglicherweise ins Leere geht an dieser Stelle. Außerdem habe ich meine wget Befehle in Skripten mit den Parametern -t3 und -T20 ergänzt (warte maximal 3 x 20 Sekunden auf Antwort). Wieder eine Fehlerquelle weniger.

Die Behandlung der Wetter-Bedingung erfolgt in folgendem Codeteil:

Code: Alles auswählen

   switch $weather {
      "Klar"              {set twilightHorizon [expr {$base_horizon + 0.2}]}
      "Meist sonnig"      {set twilightHorizon [expr {$base_horizon + 1.0}]}
      "Teils sonnig"      {set twilightHorizon [expr {$base_horizon + 1.7}]}
      "Heiter"            {set twilightHorizon [expr {$base_horizon + 1.8}]}
      "Wolkig"            {set twilightHorizon [expr {$base_horizon + 1.9}]}
      "Meistens bewölkt"  {set twilightHorizon [expr {$base_horizon + 2.0}]}
      "Leichtes Nieseln"  {set twilightHorizon [expr {$base_horizon + 4.0}]}
    }

Hier müsste man doch dann einfach einen mittleren Wert (3?) einsetzen wenn keiner der abgefragten Konstanten in weather steht!

Nachtrag: Habe gerade das hier zum switch-Befehl gefunden:
Der default-Teil enthält die Anweisung, die ausgeführt wird, wenn alle anderen
Bedingungen zuvor nicht erfüllt sind. Der default-Teil entspricht dem else-Teil im
if-Befehl.

Werde ich also ergänzen:

Code: Alles auswählen

   switch $weather {
      "Klar"              {set twilightHorizon [expr {$base_horizon + 0.2}]}
      "Meist sonnig"      {set twilightHorizon [expr {$base_horizon + 1.0}]}
      "Teils sonnig"      {set twilightHorizon [expr {$base_horizon + 1.7}]}
      "Heiter"            {set twilightHorizon [expr {$base_horizon + 1.8}]}
      "Wolkig"            {set twilightHorizon [expr {$base_horizon + 1.9}]}
      "Meistens bewölkt"  {set twilightHorizon [expr {$base_horizon + 2.0}]}
      "Leichtes Nieseln"  {set twilightHorizon [expr {$base_horizon + 4.0}]}
      default  {set twilightHorizon [expr {$base_horizon + 3.0}]}
    }

[rmeyerz]

Hallo Gert,

okay. Ich habe mich jetzt schon eine Weile nicht mehr mit dem System beschäftigt. Wenn ich eine Prüfung der Tageslichtzahl mache, dann starte ich aber doch im Zweifel das Script noch einmal, ohne es dabei korrekt beendet zu haben (Version 1.5, Start nur einmal, nicht täglich). Es könnte also sein, dass das Script noch läuft, aber hängt. Und da bin ich nicht sicher, ob ein Neustart des Scripts auf Dauer die Lösung ist. Aber, vielleicht mach ich nur einen Gedankenfehler.

Was den switch Teil anbetrifft, ist es bei mir so, dass im Programmteil der Wert erstmal auf "5" gesetzt wird: set twilightHorizon 5.0. Falls sich dann ein Wettername in der Auflistung findet, wird der Wert geändert. Ansonsten bleibt er bei 5. Also dürfte dann der default Eintrag redundant sein.

Den Teil mit den Daten Deiner eigenen Wetterstation habe ich noch nicht verstanden: Du schreibst, dass Du sie alle 15 Minuten von wunderground ausliest. Wie genau wird das gelöst: Der Abruf muss doch auch über eine Url-Adresse erfolgen. Und dann müssen die Daten ja noch irgendwie ins homematic System. Stehe da gerade auf dem Schlauch.

Bezüglich des wget Befehls habe ich auch eine Frage: Führt dies dazu, dass das Neuanlegen der Wetterwertedatei übersprungen wird und die noch vorhandene Vorversion verwendet wird? Also im Zweifel, falls er nicht wieder in Kontakt mit wunderground kommt, wird dann halt dauerhaft das alte Wetter angezeigt?

Freue mich auf eine Auffrischung meiner verrosteten Kenntnisse.
Rüdiger