Dämmerungsscript

[grmpf]

Ich lese in einem anderen Skript alle 15 Minuten die wichtigsten Daten meiner Wetterstation in Systemvariablen ein um in normalen Abfragen damit arbeiten zu können. Dabei gibt es auch eine Variable Wetter-Bedingungen die ich im twilight-Skript direkt abfrage. Dadurch vermeide ich im twilight jeglichen url Aufruf

Ja, beim switch hast Du recht. Aber bei meinem Beispiel wird der Wert auf 5+3 gesetzt,

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?

Bei meiner Variante ist das so da die Variablen immer gefüllt sind. Du könntest aber auch das "file delete" für die xml-Antwort entfernen dann müsste dem auch so sein.

[rmeyerz]

Okay. Also verwertest du die Wetterwerte direkt. Hatte ich falsch verstanden.

Leider bleibt bei mir das Script wohl einfach in dem Moment stehen, in dem keine Wetterinformationen geliefert werden. Die alte Datei wird nicht mehr gelöscht und zeigt als Zeit dann halt die letzte Aktualisierung an. Ich vermute, das Script wird nicht mehr bis zum Löschen Teil abgearbeitet.

In seltenen Fällen ist die Wetterdatei auch nicht mehr ausgefüllt mit Werten. Führt aber auch dazu, dass das Script stehen bleibt.

Rüdiger

[grmpf]

versuche es doch mal mit den obigen wget Parametern. Dann dürfte das Skript nicht hängen bleiben sondern ein erfolgloser url Aufruf sollte nach 1 Minute Geschichte sein.

[rmeyerz]

Ich versuche in der Tat jetzt mal die Sache mit -t3 und T20 beim wget Befehl. Mal schaun.

Rüdiger

[rmeyerz]

Hallo,

ich habe mir noch einmal viele Gedanken zum Script gemacht. Den wget Befehl mit -t und T zu ergänzen führt ja dazu, mehrfach Datenabrufe zu versuchen mit einer definierten Pause dazwischen. Allerdings schützt dies nicht davor, dass das Script einen Fehler produziert:

Falls auch nach dreimaligem Versuch keine Daten empfangen werden, bleibt das Script weiterhin stehen. Ursachen können bspw. folgende sein: Der Router hat gerade keinen Zugang zum Internet, die Seite mit den Wetterdaten ist vorübergehend (oder bei Adressänderung dauerhaft) nicht erreichbar, der Abruf der Wetterdaten klappt nicht und die angelegte Wetterdatei enthält somit keine Wetterdaten.

Dies alles führt dazu, dass das Script stoppt und die Variablen für die Dämmerungszeiten nicht mehr aktualisiert werden.
Mein Lösungsvorschlag aus März 2017 war ja, hier einfach die Wetterabfrage zu umgehen und davon unabhängig zu machen. Nun bin ich aber einen Schritt weiter gegangen. Besser wäre es ja, den vollen Funktionsumfang des Scripts zu nutzen. Man muss ja den wetterabhängigen Wert nicht nutzen. Grundvoraussetzung ist aber, dass das Script nicht mehr stehen bleibt, falls ein Fehler beim Abruf der Wetterdaten vorhanden ist.

Ich bin gerade dabei, eine Fehlerprüfung einzupflegen. Bei der Wetterabfrage möchte ich 1. prüfen, ob die Wetterseite momentan überhaupt erreichbar ist und 2. prüfen, ob die angelegte Wetterdatei auch mit den relevanten Wetterwerten gefüllt wurde.
Sollte eine der Bedingungen nicht erfüllt sein, wird der Wetterabhängige Horizontwert halt nicht verändert sondern verbleibt beim Standardwert von 5 und das Script läuft normal mit diesem Wert weiter. Kein Abbruch mehr wie bisher.

Wie gesagt, momentan ist alles noch in der Entwicklung. Es scheint aber im Probebetrieb zu funktionieren. Ich habe alle möglichen Fehler simuliert. Das Script läuft weiterhin fehlerfrei.

Falls also hier Bedarf an einer neuen Version besteht. Ich würde dann den Script-Code nach Abschluss der Probezeit zur Verfügung stellen. Es sind allerdings so einige Kommentarzeilen darin, die mir dabei helfen, die einzelnen Script-Teile zu verstehen. Diese könnten entweder vorher von mir entfernt werden oder jeder entscheidet selber, ob er sie löschen möchte.

[grmpf]

Ich habe festgestellt, dass meine "wetterabhängige Unter- und Aufgangszeit" nicht funktionieren, es wohl noch nie haben. Es ist nicht wichtig - aber ich verstehe nicht, wo der Fehler ist. Vielleicht findet es jemand von Euch raus:

In der Variablen Wetter-Bedingungen steht "bedeckt".
Im Log steht:
current condition is "bedeckt"
twilight horizon set to 5 (also nur der vorbelegte Wert!)
- bei "bedeckt" sollte dort aber 3 angezeigt werden!

Code: Alles auswählen

proc getTwilightHorizon {base_horizon} {
set twilightHorizon 5.0
# Wetterbedingungen werden aus der Variablen Wetter-Bedingungen direkt geholt. Das erspart die Internetverbindung
array set values [rega_script {
   var v1=dom.GetObject("Wetter-Bedingungen").Value();
   }]
   set weather $values(v1)

     log "weather aus Systemvariable Wetter-Bedingungen"
     log "current condition is \"$weather\""

   switch $weather {
      "klar"              {set twilightHorizon [expr {$base_horizon + 0.2}]}
      "sonnig"            {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}]}
      "bedeckt"			  {set twilightHorizon [expr {$base_horizon + 3.0}]}
      "Regen"			  {set twilightHorizon [expr {$base_horizon + 4.0}]}
      "leichtes Nieseln"  {set twilightHorizon [expr {$base_horizon + 4.0}]}
    }
  log "twilight horizon set to $twilightHorizon"
  return $twilightHorizon
}

[DocZoid]

Ach herrje, das ist ja jetzt 8 Jahre her . Hätte ich gewusst, dass das Script so lange verwendet wird, hätte ich es bestimmt mehr kommentiert

Ich bin jetzt eher zufällig auf den Post aufmerksam geworden und kann nicht mehr direkt zur Lösung beitragen. Das Script fliegt zwar noch irgendwo bei mir herum (kommt ja nichts weg), aber im Einsatz ist es bei mir nicht mehr. Freut mich aber, dass es immer noch Anwendung findet!

[grmpf]

Ich ziehe die Frage zurück! Ich habe natürlich wieder einen Volltreffer gelandet
Wenn base_horizon 3 ist, dann ist "bedeckt" im Ergebnis 5! - und damit in diesem Fall ZUFÄLLIG identisch dem Grundwert. Oh Mann...

@DocZoid: Dein Skript wurde hier schon einige Male modifiziert aber auf diesem Skript basiert bei jeder von mir aufgesetzten CCU die Steuerung von Rollläden, Außenbel. etc!! Also Danke dafür!

[grmpf]

Hier mal wieder eine aktualisierte, komplett überarbeitete Version ohne die Umlaute bei Dämmerung, die merkwürdigerweise manchmal Probleme bereiten, und ohne Wetterabfrage über wget weil dieser Befehl sich in vielerlei Hinsicht als problematisch für den Betrieb erwiesen hat.

Code: Alles auswählen

#!/bin/tclsh
#Original von DocZoid 2011
#Version 1.5 mod by rmeyerz (calcTwilightTimes)
#Modifikation w/ wget Problemen by grmpf (2018)

#Version für Umlautprobleme (haben manche CCUs): OHNE UMLAUTE BEI Daemmerung

#Aufruf:
#param 0 = Breitengrad (nördlich)
#param 1 = Längengrad (östlich)
#param 2 = künstlicher Horizont
#param 3 = PLZ

#Systemvariablen in WebUI anlegen:
# Daemmerungszeiten (Zeichenkette)
# Daemmerung (Zeichenkette)
# Tageslicht (Zahl)
# Wetter-Bedingungen (Zeichenkette, bei Bedarf mit Werten wie z. B. "klar" füllen)

# Skript in Verzeichnis /usr/local/addons/twilight/ kopieren und entweder über CUXD oder System.exec einmalig nach Restart aufrufen
# Im gleichen Verzeichnis muss die daemonize.tcl liegen

#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 einfach (ggf. vorbelegte) Systemvariable
#
proc getTwilightHorizon {base_horizon} {
set twilightHorizon 5.0
# wget-Befehle sind für das Skript tödlich wenn sie ins Leere laufen. Wegen Unwichtigkeit der Wetterabhängigen Dämmerung auf Systemvariable umgestellt
# Die Variable bietet immerhin noch die Möglichkeit, die Wetterbedingungen anderweitig einzuspeisen
# Wetterbedingungen werden aus der Variablen Wetter-Bedingungen direkt geholt. Das erspart die Internetverbindung
array set values [rega_script {
   var v1=dom.GetObject("Wetter-Bedingungen").Value();
   }]
   set weather $values(v1)

     log "weather aus Systemvariable Wetter-Bedingungen"
     log "current condition is \"$weather\""

   switch $weather {
      "klar"              {set twilightHorizon [expr {$base_horizon + 0.2}]}
      "sonnig"            {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}]}
      "bedeckt"			  {set twilightHorizon [expr {$base_horizon + 3.0}]}
      "Regen"			  {set twilightHorizon [expr {$base_horizon + 4.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('Daemmerungszeiten').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('Daemmerung').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('Daemmerung').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

[vo2]

Falls also hier Bedarf an einer neuen Version besteht. Ich würde dann den Script-Code nach Abschluss der Probezeit zur Verfügung stellen. Es sind allerdings so einige Kommentarzeilen darin, die mir dabei helfen, die einzelnen Script-Teile zu verstehen. Diese könnten entweder vorher von mir entfernt werden oder jeder entscheidet selber, ob er sie löschen möchte.

Bei mir besteht Bedarf. Ich setzte das Script von Anfang an ein. Zum Teil mit eigenen Modifikationen. Hab aber nie die Zeit gehabt den borstigen Wetterteil zu überarbeiten. Bei mir kam es eh nur so ein bis zwei mal im Jahr zu Komplikationen. Und das DocZoid sich nach 8 Jahren meldet find ich witzig. Dein Script war eines meiner ersten und läuft seit der ersten Stunde. Danke.