Tages / Jahreszeit

Hallo zusammen
Schade dass diese Szene immer auf Frühling stehen bleibt, welcher LUA Spezi könnte das Problem beheben?
Vielen Dank…
Gruss fastsnake


--[[
%% autostart
%% properties
%% globals
--]]

-- ------------- Skript setDayTime --------------------------------------------

-- Hier Debugmode auf true setzen und es wird ein Simulationstag (24 Std) durchlaufen, 
-- der dir die moeglichen Ergebnisse zeigt jedoch keine Globale Variable ändert 
-- und keinen Timeout setzt
local debugMode = false 

-- Name der Globalen Variable im Home Center
local timeOfDayGlobalName = "Tageszeit"

-- Mapping der TimeOfDay Eintraege in beliebiger Sprache 
-- der globalen Variable TimeOfDay entsprechend
local timeOfDayLabelMap = {Morning="Morgen", Day="Tag", Evening="Abend", Night="Nacht"}

-- Name der Globalen Variable im Home Center
local SeasonGlobalName = "Jahreszeit"

-- Mapping der Jahreszeit Eintraege in beliebiger Sprache 
-- der globalen Variable Jahreszeit entsprechend
local SeasonLabelMap = {Fruehling="Fruehling", Sommer="Sommer", Herbst="Herbst", Winter="Winter"}

local sourceTrigger = fibaro:getSourceTrigger()

local dayTimeList

--Color debugging
function ExtraDebug( color, message )
	--if (debugMode) then 
    	fibaro:debug(string.format('<%s style="color:%s;">%s</%s>', "span", color, message, "span")); 
	--end
end

-- Berechnet Uhrzeit in Sekunden (Differenz) ab 0:00 Uhr
function getTimeSecsDiff(s)
  local hours, minutes = string.match(s, "(%d+):(%d+)")
   -- Sekunden = Stunden * 60 (mins) * 60 (secs) + Minuten * 60 (secs)
  local calcSecs = (hours-1) * 60 * 60 + minutes * 60 
  return calcSecs
end  

--Start
function InitTimeOfDay()
	-- Strings Sonnenauf/-untergang im Format Stunde:Minute von fibaro geliefert
	local sunrise = fibaro:getValue(1, "sunriseHour")   -- Sonnenaufgang
	local sunset  = fibaro:getValue(1, "sunsetHour")    -- Sonnenuntergang

	-- Auslesen der aktuellen Jahreszeit (Globale Variable)
	local season = fibaro:getGlobal(SeasonGlobalName)
  
    Debug = function ( color, message ) fibaro:debug(string.format('<%s style="color:%s;">%s', "span", color, message, "span")) end

    Debug("cyan","--------------------------------------------------------------")
    function DT(DATETIME)
    local WD = {'Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag'}
    local M = {'Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'}
    local tableDT= (os.date('*t', tonumber(DATETIME))) 
    tableDT.month = M[tonumber(tableDT.month)]
    tableDT.wday =  WD[tonumber(tableDT.wday)]
    return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date "" 
end 
    x= DT(os.date())
    --fibaro:debug (x) 
    Debug("cyan",(x))
  
    Debug("cyan","--------------------------------------------------------------")
	Debug("steelblue",(string.format("Globale Variable '%s' aktueller Wert: '%s'", "Jahreszeit", season)))

	-- Angaben der Bereichsgrenzen:
	--
	-- Hier koennen die Grenzen angeben werden, ab wann ein neuer Tagesbereich anfaengt.
	-- Der Erste Wert ist die Uhrzeit im Format Stunde:Minute, der zweite Wert  
	-- entspricht einem Offset (Verzoegerung) in Minuten bezogen auf den ersten Wert.
	-- Als ersten Wert koennen auch die Variablen sunset/sunrise genommen werden.
	--
	-- Beispiele:
	-- 
	-- globalMorning = { sunrise,  30 }  => Morgen beginnt 30 Minuten nach Sonnenaufgang
	-- globalMorning = { sunrise, -30 }  => Morgen beginnt 30 Minuten vor Sonnenaufgang
	-- globalEvening = { "18:00",   0 }  => Abend beginnt um genau 18:00 Uhr
	-- globalEvening = { sunset,   80 }  => Abend beginnt 80 Minuten nach Sonnenuntergang

	-- Allgemeine Zeiten; Gelten immer falls keine Zeiten angegeben wurden fuer die aktuelle Jahreszeit (Uebersteuerung)
	local globalMorning = { sunrise, 0 }
	local globalDay     = { "10:00", 0 }
	local globalEvening = { sunset, 0 }  
	local globalNight   = { "22:00", 0 }

	-- Hier koennen beliebige Zeiten eingegeben werden fuer die aktuelle Jahreszeit. 
	-- Der nil Wert bedeutet hier, das die globale Einstellung uebernommen werden soll
	-- Die Werte muessen der Reihenfolge Morgen Tag Abend und Nacht entsprechen.
	local seasonTimeTable = { Fruehling = { { sunrise, 0 }, 
	                                        { "10:00", 0 }, 
	                                        { sunset,  -240 },
	                                        { "22:00", 0 } },
	                       
	                          Sommer    = { { sunrise, 0 }, 
	                                        { "09:00", 0 }, 
	                                        { sunset,  -180 },
	                                        { "22:00", 0 } },                       
	                       
	                          Herbst    = { { sunrise, 0 }, 
	                                        { "10:00", 0 }, 
	                                        { sunset,  -120 },
	                                        { "22:00", 0 } },
	                       
	                          Winter    = { { sunrise, 0 }, 
	                                        { "11:00", 0 }, 
	                                        { sunset, 0 },
	                                        { "22:00", 0 } }
	                        }
	
	--
	-- =========> Ab hier sind keine Einstellungen noetig  
	--

	-- hier werden die Werte der Jahreszeit entsprechend (falls angegeben) uebernommen
	-- ansonsten gelten die globalen Angaben
	morning = globalMorning          
	if (seasonTimeTable[season][1]) then
	  morning = seasonTimeTable[season][1]
	end

	day = globalDay          
	if (seasonTimeTable[season][2]) then
	  day = seasonTimeTable[season][2]
	end

	evening = globalEvening          
	if (seasonTimeTable[season][3]) then
	  evening = seasonTimeTable[season][3]
	end

	night = globalNight          
	if (seasonTimeTable[season][4]) then
	  night = seasonTimeTable[season][4]
	end

	-- Umrechnung der Bereichsgrenze in Sekunden ab 0:00 Uhr (Differenz)
	morning = getTimeSecsDiff(morning[1]) + morning[2] * 60
	day     = getTimeSecsDiff(day[1]) + day[2] * 60
	evening = getTimeSecsDiff(evening[1]) + evening[2] * 60                
	night   = getTimeSecsDiff(night[1]) + night[2] * 60

	--if (debugMode) then
	  Debug("steelblue","--------------------- Voreinstellungen ---------------------")
	  
      Debug("steelblue",(string.format("Es ist die Jahreszeit %s",season)))
	  Debug("darkorange",(string.format("%s Uhr Sonnenaufgang",sunrise)))
	  Debug("orangered",(string.format("%s Uhr Sonnenuntergang",sunset)))                                                                              
	  Debug("yellowgreen",(string.format("%s Uhr Morgen",os.date("%H:%M", morning))))
	  Debug("yellow",(string.format("%s Uhr Tag",os.date("%H:%M", day))))
	  Debug("gray",(string.format("%s Uhr Abend",os.date("%H:%M", evening))))
	  Debug("darkslategray",(string.format("%s Uhr Nacht",os.date("%H:%M", night))))
      Debug("palegoldenrod","--------------------- Aktueller Wert ------------------------")
	--end

	-- Table der Bereichsgrenzen
	dayTimeList = {
	                      {label = timeOfDayLabelMap.Morning, secs = morning},
	                      {label = timeOfDayLabelMap.Day,     secs = day},
	                      {label = timeOfDayLabelMap.Evening, secs = evening},
	                      {label = timeOfDayLabelMap.Night,   secs = night},
	                    }
                    
	-- Sortierung der Bereichsgrenzen nach Zeit (secs)                    
	local sort_func = function( a,b ) return a.secs < b.secs end
	table.sort(dayTimeList, sort_func)

end
  

-- Hauptfunktion zum setzen der Globalen Variable TimeOfDay 
function setTimeOfDay() 

  InitTimeOfDay() --Initialisierung in die Hauptfunktion mit rein! Sonst wird sunset, sunrise, season nicht aktualisiert.
  
  local aktTime = 0;
  local doLoop = true;
  local loopHour = 0; 
  local timeout = 0
  local setDayTime = nil

  if (debugMode) then
     Debug("green","------------------- Beginne Auswertung ------------------")
  end 
        
  repeat

    local timeOfDayCur = fibaro:getGlobalValue(timeOfDayGlobalName)
    Debug("palegoldenrod",(string.format("Globale Variable '%s' aktueller Wert: '%s'", timeOfDayGlobalName, timeOfDayCur)))
    Debug("mediumseagreen","--------------------- Beginne Auswertung ------------------")
    if (debugMode) then
      -- Testzeit zur Simulation         
      aktTime = getTimeSecsDiff(string.format("%02d:00",loopHour)) 
      if (loopHour == 24)then
        doLoop = false
      end
      loopHour = loopHour + 1
    else  
      -- aktuelle Zeit in Sekunden (Differenz)
      aktTime = getTimeSecsDiff(os.date("%H:%M"))
      doLoop = false
    end
    
    for i, record in ipairs( dayTimeList ) do
      
      if (aktTime < record.secs) then
        if (i == 1) then
          -- falls match beim ersten Element nehme 
          -- den letzte Zeitbereich in der Liste
          setDayTime = dayTimeList[#dayTimeList].label
        else  
          setDayTime = dayTimeList[i-1].label
        end   
        timeout = record.secs - aktTime;
        break;
      else
        setDayTime = nil  
      end  
      
      lastDayTime = record.label 
      
      if (i == 1) then
        firstSec = record.secs
      end  
    end
    
    -- Falls Zeitgrenze ueber Datumswechsel muss der Timeout extra berechnet werden
    if ( setDayTime == nil ) then
      setDayTime = lastDayTime
      timeout = 86400 - aktTime + firstSec 
    end  
    Debug("mediumseagreen",(string.format("Es ist '%s' Uhr => setze Globale Variable '%s' auf '%s'", os.date("%H:%M", aktTime), timeOfDayGlobalName, setDayTime)))
    
    -- setze globale Variable
    if (not debugMode) then
      Debug("mediumseagreen",(string.format("Globale Variable '%s' auf den Wert '%s' gesetzt", timeOfDayGlobalName, setDayTime)))
      fibaro:setGlobal(timeOfDayGlobalName, setDayTime)
    end; 
    
    -- Die Szene pausiert bis zum Wechsel in den naechsten Tagesbereich
    fibaro:debug(string.format("Timeout für %.2f Minuten", timeout/60))

  until not doLoop   
    
  if (not debugMode) then
    -- Setze Timeout
    --fibaro:debug( string.format("vor Timeeout:"));
    setTimeout(setTimeOfDay, timeout*1000)
  end;
     
end

--
-- ================ Main ( Aufruf Verarbeitung ) ==============================             
--

setTimeOfDay()

Moin Fastsnake,

Leider kein wirklicher “LUA Spezi”, aber dazu gibt es bereits einen Thread und Ändy hat dort einen Vorschlag eingestellt . Ich habe das selbst so noch nicht umgesetzt und behelfe mir mit einer zweiten Szene welche das Skript täglich neu startet (s.u.). Funktioniert einwandfrei ist aber natürlich etwas weniger elegant.

Einfach in der Szene die 129 durch die ID Deiner Szene ersetzen und evtl. die Startzeit (hier 00:30) anpassen. Die Jahreszeitenvariablen müssen natürlich an anderer Stelle gesetzt werden (steht auch im oben genannten Thread)

Gruß
Alex

--[[
%% autostart
%% properties
%% weather
%% events
%% globals
--]]

---------------------------------------------------
--------- Farbiges Debug --------------------------
Debug = function ( color, message )
  fibaro:debug(string.format('<%s style="color:%s;">%s', "span", color, message, "span"))
end
---------------------------------------------------
--------- Schleifenschutz -------------------------
if (fibaro:countScenes()>1) then
fibaro:debug('Kill the second scene!');
fibaro:abort();
end

local sourceTrigger = fibaro:getSourceTrigger();
function tempFunc()
local currentDate = os.date("*t");
local startSource = fibaro:getSourceTrigger();
if (
 ( ((currentDate.wday == 1 or currentDate.wday == 2 or currentDate.wday == 3 or currentDate.wday == 4 or currentDate.wday == 5 or currentDate.wday == 6 or currentDate.wday == 7) and string.format("%02d", currentDate.hour) .. ":" .. string.format("%02d", currentDate.min) == "00:30") )
)
then
  Debug('red', 'Heute ist der '..os.date('%d.%m.%Y')..'. Es ist '..os.date('%H:%M')..' Uhr.')
  Debug( 'magenta', 'Kill und Neustart Szene')
  fibaro:killScenes(129) -- ID Tageszeiten2
       fibaro:sleep(1000)
  fibaro:startScene(129) -- ID Tageszeiten2
end

setTimeout(tempFunc, 60*1000)
end
if (sourceTrigger["type"] == "autostart") then
tempFunc()
else

local currentDate = os.date("*t");
local startSource = fibaro:getSourceTrigger();
if (
startSource["type"] == "other"
)
then
  Debug('red', 'Heute ist der '..os.date('%d.%m.%Y')..'. Es ist '..os.date('%H:%M')..' Uhr.')
  Debug( 'red', 'MANUELL   Kill und Neustart Szene')
  fibaro:killScenes(129) -- ID Tageszeiten2
       fibaro:sleep(1000)
  fibaro:startScene(129) -- ID Tageszeiten2
end

end

Hallo Alex
Funktioniert super Dein Script, werde versuchen die beiden Szenen (Jahreszeiten und das obige Script) zusammen zu fassen.
Vielen Dank für Deine Hilfe…
Gruss Willi

Habe das erstmal so gelöst…
Gruss Willi

--[[
%% autostart
%% properties
%% globals
--]]

    ----------------------------------------------------------------------------------------------------------
    local debugging = true --(true= on / false=off)
    local zeitschaltung = 0030
    ----------------------------------------------------------------------------------------------------------

    --Color debugging
    function ExtraDebug( color, message )
    if (debugging) 
    then
      fibaro:debug(string.format('<%s style="color:%s;">%s</%s>', "span", color, message, "span")); 
    end
    end
	
    function WhichSeason() 

	year 	= tonumber(os.date("%Y"));
	month 	= tonumber(os.date("%m"));
	day 	= tonumber(os.date("%d"));
	hour 	= tonumber(os.date("%H"));
	min 	= tonumber(os.date("%M"));
	weekday = tonumber(os.date("%w"));
	local tNow = os.date("*t")
	local dayofyear = tNow.yday
	local season
	if (dayofyear >= 79) and (dayofyear < 172) then season = "Fruehling"
    elseif (dayofyear >= 172) and (dayofyear < 265) then season = "Sommer"
    elseif (dayofyear >= 265) and (dayofyear < 355) then season = "Herbst"
	else season = "Winter"
	end
  
	if (fibaro:getGlobal("Jahreszeit") ~= season)
    then 
    fibaro:setGlobal("Jahreszeit", tostring(season))
   
    function DT(DATETIME)
    local WD = {'Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag'}
    local M = {'Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'}
    local tableDT= (os.date('*t', tonumber(DATETIME))) 
    tableDT.month = M[tonumber(tableDT.month)]
    tableDT.wday =  WD[tonumber(tableDT.wday)]
    return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date "" 
    end 
    x= DT(os.date())
    ExtraDebug("white",(x))
    
    ExtraDebug( 'magenta', 'Kill und Neustart der Szene Tages / Jahreszeiten')
    fibaro:sleep(3000)
    fibaro:killScenes(328) -- ID Tages / Jahreszeiten
    fibaro:sleep(1000)
    fibaro:startScene(328) -- ID Tages / Jahreszeiten
    ExtraDebug("cyan", "Jahreszeit auf "  .. season .." gewechselt!");
    ExtraDebug("cyan","--------------------------------------------------------------")
		
	end
    end

    -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    -- SZENE JEDEN TAG UM 00:30 AUSFÜHREN
    -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    local sourceTrigger = fibaro:getSourceTrigger();

    function tempFunc()
    local currentDate = os.date("*t");
    local startSource = fibaro:getSourceTrigger();
  
    if ((((currentDate.wday == 1 or currentDate.wday == 2 or currentDate.wday == 3 or currentDate.wday == 4 or currentDate.wday == 5 or currentDate.wday == 6 or currentDate.wday == 7) 
    and (tonumber(os.date("%H%M")) == zeitschaltung)))) 
    then
    WhichSeason()
    end
    setTimeout(tempFunc, 60*1000)
    end

    if (sourceTrigger["type"] == "autostart") 
    then
    tempFunc()
   
    else
    local currentDate = os.date("*t");
    local startSource = fibaro:getSourceTrigger();
  
    if (startSource["type"] == "other") 
    then
    WhichSeason()
    end
    end