Google Wetterserver down?

[Henk]

Ahhh...es hatte einen anderen Grund!

Ich habe mir die erstellte XML nochmal angeschaut und festgestellt, dass der Key falsch war.
Das ist auf der Wunderground-Seite etwas irreführend, da dort unten auch noch ein Key angegeben wird.

Vielen Dank
Henk

[rmeyerz]

Hier stelle ich meine vorübergehende Komplettlösung vor. Hierbei habe ich mich auf die Variante "Lösung über Weather Underground" bezogen.

Ein Dank geht an chbaechle, der hierfür die Grundbasis gesetzt hat.

Da ich Wert auf eine Anzeige von möglichst vielen Parameter im Display der CCU lege, wird das Ganze folgendermaßen gestartet:

Code: Alles auswählen

string stderr;
string stdout;
system.Exec("sh /etc/config/addons/lcd_msg/display_weather.sh <Deine Key-Id bei Weather Underground> <Dein Ort in Deutschland>",&stdout, &stderr);

Die beiden Parameter ohne Klammern eingeben. Es ist also eine Anmeldung bei Weather Undergroung notwendig. Hierzu wurde einiges geschrieben.
Neben dem weather.tcl Script muss natürlich auch das lcd_msg addon vorhanden sein:

http://www.homematic-wiki.info/mw/index ... on:lcd_msg

Das eigentliche Script funktioniert durch die Übergabe der Parameter dann ohne weitere Änderung:

Code: Alles auswählen

#!/bin/tclsh

load tclrega.so

#
# Read weather data
#

#param 0 = Persönliche key-ID auf Wetter Underground

#param 1 = Ort in Deutschland





set url http://api.wunderground.com/api/[lindex $argv 0]/conditions/forecast/lang:DL/q/germany/[lindex $argv 1].xml

exec /usr/bin/wget -q -O /tmp/weatherdata.xml $url

set f [open "/tmp/weatherdata.xml"]
set input [read $f]
close $f

#
# Aktuelles Wetter
#
regexp "<current_observation>(.*?)</current_observation>" $input dummy current  ; #get current observation
regexp "<temp_c>(.*?)</temp_c>" $current dummy temp_c  ; #get current temp
regexp "<wind_dir>(.*?)</wind_dir>" $current dummy wind_dir  ; #get current wind direction 
regexp "<relative_humidity>(.*?)</relative_humidity>" $current dummy humidity ; #get humidity
regexp "<weather>(.*?)</weather>" $current dummy weather  ; #get current weather 
regexp "<wind_kph>(.*?)</wind_kph>" $current dummy wind_kph  ; #get current windgeschwindigkeit 
regexp "<visibility_km>(.*?)</visibility_km>" $current dummy sichtweite  ; #get visibility

# Sichtweiten Anzeige als Text mit Zusatz Kilometer
set sichtweite "$sichtweite km"


# Ersetzung der kryptischen Zeichen bedingt durch falsche Umlautdarstellung

switch $wind_dir {
  "Südwest"          {set wind_dir "Südwest"}
  "Südost"           {set wind_dir "Südost"}
  "West-Südwest"     {set wind_dir "West-Südwest"}
  "Süd-Südwest"     {set wind_dir "Süd-Südwest"}
  "Ost-Südost"       {set wind_dir "Ost-Südost"}
  "Süd-Südost"      {set wind_dir "Süd-Südost"}
}



#Wettervorhersage für den aktuellen Tag

regexp "<simpleforecast>(.*?)</simpleforecast>" $input dummy text  ; #get second forecast section
regexp "<forecastday>(.*?)</forecastday>.*?<forecastday>(.*?)</forecastday>" $text -> day0 day1 ; #split days

#day0
regexp "<high>(.*?)</high>" $day0 dummy temp  ; #get high values
regexp "<celsius>(.*?)</celsius>" $temp dummy maxtemp  ; #get deg Celsius
regexp "<low>(.*?)</low>" $day0 dummy temp  ; #get high values
regexp "<celsius>(.*?)</celsius>" $temp dummy mintemp  ; #get deg Celsius
regexp "<conditions>(.*?)</conditions>" $day0 dummy conditions0  ; #get Wettervorhersage als Text
regexp "<pop>(.*?)</pop>" $day0 dummy rainpop  ; #get Regenwahrscheinlichkeit

set minbismaxtemp "$mintemp/$maxtemp Grad"

# Siehe oben, Problem mit Umlauten
switch $conditions0 {
    "Regen möglich"     {set conditions0 "evtl. Regen"}
    "Gewitter möglich"  {set conditions0 "Gewitter?"}
}



#erwartete Regenmenge für den aktuellen Tag in Milimetern

regexp "<qpf_allday>(.*?)</qpf_allday>" $day0 dummy rain  ; #get rain
regexp "<mm>(.*?)</mm>" $rain dummy rain0  ; #get mm

#gleiches für Schmeemenge in Zentimeter
regexp "<snow_allday>(.*?)</snow_allday>" $day0 dummy snow  ; #get snow
regexp "<cm>(.*?)</cm>" $snow dummy snow0  ; #get cm





# Anzeige im Display CCU
 
set weather_msg "\$m4h p900 gwetter r400\$$temp_c°$mintemp/$maxtemp°<br/>$humidity $rain0 mm|Regenrisiko<br/>$rainpop Prozent|$wind_kph km/h<br/>$wind_dir|Sichtweite:<br/>$sichtweite|Aktuell:<br/>$weather|Vorhersage:<br/>$conditions0"

  puts $weather_msg

  catch {exec /bin/sh /etc/config/addons/lcd_msg/display_msg.sh "$weather_msg"}


# Ende Anzeige im Display CCU

# set ReGaHss variables
#
set rega_cmd ""
append rega_cmd "var c0 = dom.GetObject('Temperatur');"
append rega_cmd "var c1 = dom.GetObject('Windrichtung');"
append rega_cmd "var c2 = dom.GetObject('Luftfeuchtigkeit');"
append rega_cmd "var c3 = dom.GetObject('Wetterbedingung');"
append rega_cmd "var c4 = dom.GetObject('Windgeschwindigkeit');"

append rega_cmd "var c5 = dom.GetObject('Min-Temperatur');"
append rega_cmd "var c6 = dom.GetObject('Max-Temperatur');"
append rega_cmd "var c7 = dom.GetObject('Wahrscheinliche Regenmenge');"
append rega_cmd "var c8 = dom.GetObject('Wahrscheinliche Schneefallhöhe');"
append rega_cmd "var c9 = dom.GetObject('Sichtweite');"
append rega_cmd "var c10 = dom.GetObject('Wettervorhersage');"
append rega_cmd "var c11 = dom.GetObject('Regenwahrscheinlichkeit');"
append rega_cmd "var c12 = dom.GetObject('MinTemperatur/MaxTemperatur');"


append rega_cmd "c0.State('$temp_c');"
append rega_cmd "c1.State('$wind_dir');"
append rega_cmd "c2.State('$humidity');"
append rega_cmd "c3.State('$weather');"
append rega_cmd "c4.State('$wind_kph');"

append rega_cmd "c5.State('$mintemp');"
append rega_cmd "c6.State('$maxtemp');"
append rega_cmd "c7.State('$rain0');"
append rega_cmd "c8.State('$snow0');"
append rega_cmd "c9.State('$sichtweite');"
append rega_cmd "c10.State('$conditions0');"
append rega_cmd "c11.State('$rainpop');"
append rega_cmd "c12.State('$minbismaxtemp');"


rega_script $rega_cmd

Es werden für die Windrichtungen schon die Umlaute richtig dargestellt. Für die Wetterbedingungen teilweise. Wird dann im Laufe der Zeit angepasst.
Es werden die aktuellen Daten und die Daten für die Prognose des aktuellen Tages ausgelesen.
Folgende Variablen sind in der WebUI noch anzulegen (die meisten als Zahl):

Temperatur
Windrichtung als Zeichenkette
Luftfeuchtigkeit
Wetterbedingung als Zeichenkette
Windgeschwindigkeit
Min-Temperatur
Max-Temperatur
Wahrscheinliche Regenmenge
Wahrscheinliche Schneefallhöhe
Sichtweite als Zeichenkette
Wettervorhersage als Zeichenkette
Regenwahrscheinlichkeit
MinTemperatur/MaxTemperatur als Zeichenkette

Es müssen natürlich nicht alle Variablen angelegt werden. Je nach Bedarf.
Meine Anzeige im Display ist sehr ausführlich und auf mehreren Seiten verteilt:

set weather_msg "\$m4h p900 gwetter r400\$$temp_c°$mintemp/$maxtemp°<br/>$humidity $rain0 mm|Regenrisiko<br/>$rainpop Prozent|$wind_kph km/h<br/>$wind_dir|Sichtweite:<br/>$sichtweite|Aktuell:<br/>$weather|Vorhersage:<br/>$conditions0"

Wer weniger möchte, kann den ein oder anderen Parameter herausnehmen. Die Zeichen "|" stellen einen Seitenumbruch dar. <br/>einen Zeilenwechsel.
Also die Lösung ist bestimmt nicht für Anfänger. Aber wer sich schon etwas damit beschäftigt hat, kann das Ganze glaube ich ganz gut an die Bedürfnisse anpassen und evtl. auch Vorhersagen für weitere Tage nach vorne mit aufnehmen.

Gruß
rmeyerz

[rmeyerz]

Hier mein Lösungsvorschlag für das Script twilight.tcl, dass ja auch auf den Google Dienst zugriff.

Ich habe folgenden Code für den Teil "getTwilightHorizon" geändert (Ein Dank geht an DocZoid für das Ursprungs-Script):

Code: Alles auswählen

proc getTwilightHorizon {base_horizon} {
  set url http://api.wunderground.com/api/<deine key-Id>/conditions/lang:DL/q/germany/<dein 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
}

Spitze Klammern weren nicht mit eingegeben. Man muss somit bei weather underground registriert sein.

Die Ersetzungen (im switch Teil) stammen noch zum Teil aus dem Google Dienst und man muss erstmal schauen, wie die Bezeichnungen bei weather underground sind. Die Zahlenwerte können auch individuell an die Bedürfnisse angepasst werden. Je höher der Wert, desto früher ist der wetterabhängige Untergang bzw. desto später ist der wetterabhängige Aufgang.

Gruß
rmeyerz

[grmpf]

Das Skript hat einen Fehler:
In STDERR steht:

Code: Alles auswählen

called "getTwilightHorizon" with too many arguments
    while executing
"getTwilightHorizon $logfile $plz $indoor_horizon"
    ("while" body line 52)
    invoked from within
"while {1} {
  set timezone [expr {([clock scan "0 UTC"] - [clock scan "0"]) / 3600.0}]
  set now [clock seconds]
  set twilight_midnight [expr {[clock..."
    (file "/usr/local/addons/twilight/Twilight_1.5_mod-rmeyerz.tcl" line 176)

und nochwas: Ich finde in /tmp die ausgelesene xml-Datei nicht (Aufruf der url im Browser klappt anstandslos)

Kann es sein, dass der Aufruf der Unterprozedur nur

Code: Alles auswählen

getTwilightHorizon $indoor_horizon

lauten muss??
$logfile und $plz werden in deiner Proc ja nicht benutzt.

Und die Dämmerungszeiten Wetterabhängig sehen auch komisch aus:

[grmpf]

Ich glaub ich habs jetzt:
Ich habe im Skript in Deiner Proc der Einfachheit halbe die beiden Argumente logfile und plz davorgesetzt, auch wenn die plz nicht genutzt wird. Jetzt läufts anscheindend; zumndest steht im log

Code: Alles auswählen

11:33:45: args: 50.3 8.8 2 61206
11:33:45: timezone: 2.0, twilight midnight: 01:22:14, dayofyear: 251.8275154
11:33:45: calculated twilight times: sunrise 08., 04:53:58, sunset 08., 21:50:30 for astronomical (1)
11:33:45: calculated twilight times: sunrise 08., 05:36:52, sunset 08., 21:07:36 for nautical (2)
11:33:45: calculated twilight times: sunrise 08., 06:16:56, sunset 08., 20:27:33 for civil (3)
11:33:45: calculated twilight times: sunrise 08., 06:50:09, sunset 08., 19:54:20 for standard (4)
11:33:45: calculated twilight times: sunrise 08., 07:08:04, sunset 08., 19:36:25 for indoor (5)
11:33:45: calculated twilight times: sunrise 08., 07:08:05, sunset 08., 19:04:25 for weather (6)
11:33:45: retrieving weather condition for sunrise
11:33:50: current condition is "Heiter"
11:33:50: twilight horizon set to 3.8
11:33:50: weather sunrise at 07:19:23
11:33:50: current twilight state 6 (Wetterabh.), sunlight state 6, next at 19:04:25
11:33:50: waiting 27035 s until Sat Sep 08 19:04:25 CEST 2012

Es bleibt die Frage warum ich die xml nicht finde; die müsste doch in /tmp stehen, oder???

[Pezi737]

Könntet ihr bitte nochmal den ganzen Code ab proc posten? Will bei mir noch nicht so recht klappen...
Vielen Dank!

[rmeyerz]

zum Thema twilight.tcl Script:
hier meine Zeile mit dem Aufruf des Programmes:

Code: Alles auswählen

 calcTwilightTimes $latitude $longitude $timezone $dayofyear [getTwilightHorizon $indoor_horizon] sunrise_weather dummy

Das Programm arbeitet mit einer Inputvariable, somit wird beim Aufruf auch nur die eine Variable übergeben. Und der indoor_horizon wird ja beim Programmstart als Argument mit übergeben.

Wenn mann sich das Programm bis zum Ende anschaut, sieht man, dass die xml-Datei wieder gelöscht wird. Diese dient ja nur dazu, schnell die Wetterbedingung einzulesen und sonst zu gar nicht. Nicht verwechseln mit der weatherdata.xml, die ja über das weather.tcl Script angelegt wird. Diese sollte da sein.

Das Proc selber ist ja komplett in meinem Beitrag zu sehen. Hat sich nicht geändert.
Was die Zeiten anbetrifft für die Dämmerung: Bitte selber für sich passende Werte eintragen.

Ich nutze die Vorversion von twilight.tcl, die sich nocht täglich einmal startet. Daher kann es sein, dass es bei euch anders aussieht und Korrekturen bei Variblen etc. erforderlich sind.

[grmpf]

Hier ist nochmal das komplette twilight.tcl skript. Mit den Änderungen von rmeyerz. ACHTUNG: <KEY> und <ORT> ersetzen!
Es handelt sich hier um die "final" die nur noch einmal aufgerufen wird mit den Änderungen w/ Dämmerung und Google von rmeyerz.

#!/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 /www/addons/lcd_msg/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>/c ... /<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

• 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

[rmeyerz]

Schön, dass offensichtlich alles, auch in der 1.5er Version des twilight-Scriptes, funktioniert.

Kleiner Nachtrag. Im weathler.tcl Script fehlt die Umlautübersetzung für "Süd".
Hier der Beginn des Programmteils:

Code: Alles auswählen

switch $wind_dir {
  "Südwest"          {set wind_dir "Südwest"}
  "Südost"           {set wind_dir "Südost"}

Man kann einfach folgende Zeile hinzufügen:

Code: Alles auswählen

"Süd"          {set wind_dir "Süd"}

[Chaosmax]

nachdem das Skript die ersten Tage problemlos seinen Dienst verrichtet hat, führt inzwischen jedes aufrufen dazu, dass sich die CCU verabschiedet und nur noch durch drücken des Resetknopfes wieder erweckt werden kann. Verstehe überhaut wie das sein kann.

Edit: Sorry ich meine das Wetter-Skript von chbaechle!