Hallo Ihr,
Ich habe hier ein Script, dass den Kelvin Wert an die jeweilige Tageszeit anpasst.
Morgens gehts in Richtung Tageslichtweiß und Abends wieder Richtung Warmweiß.
Da sich Sonnenauf- und untergang jeden Tag ändern, ist es an das Astroskript angelegt.
Die Kelvinwerte, die man an einer bestimmten Tageszeit möchte, kann man per Datenpunkt ändern.
Den aktuellen Kelvin Wert gibts per Datenpunkt, damit man das an die jeweiligen Leuchten weiterleiten kann.
Da meine Leuchtmittel von unterschiedlichen Hersteller sind, muss ich das noch mit einem Offset anpassen, damit ich überall die gleiche Farbe habe. Ist aber noch in arbeit...
Viel Spaß beim ausprobieren 
Das Skript funktioniert nur mit der Astro Funktion! (unten angehängt)
var INTERVAL_MS = 1000 * 60
var ASTRO_DAYTIME = "javascript.0.Astro.Tageszeit.current";
var DYNAMIC_LIGHT = "javascript.0.Dynamisches_Licht.Hilfswert_Kelvin";
var KELVIN_DAYBREAK = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Morgendämmerung";
var KELVIN_SUNRISE = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Sonnenaufgang";
var KELVIN_FORENOON = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Vormittag";
var KELVIN_NOON = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Mittag";
var KELVIN_TWILIGHT = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Abendämmerung";
var KELVIN_EVE = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Abend";
var KELVIN_NIGHT = "javascript.0.Dynamisches_Licht.Kelvin_Werte.Nacht";
var interval
/**
* @param step Die Höhe der Schritte um die Kelvinzahl anzupassen
* @param runs Anzahl der Durchläufe
*/
function startDimmer (step, runs) {
if (interval) {
clearInterval(interval);
}
//Startwert setzen für Hilfswert_Kelvin
setStartKelvinState();
var counter = 0
interval = setInterval(function() {
var kelvin = getKelvinState()
setKelvin(Math.round(kelvin + step));
// Hilfswert Kelvin ist ein Datenpunkt für die Übergabe an die Leuchten
counter = counter + 1;
if (counter >= runs) {
console.log("Ende dimmer");
clearInterval(interval);
return
}
}, INTERVAL_MS);
console.log("Start dimmer");
}
/** HELPER FUNCTIONS **/
function getMinutes (time) {
var dateString = time.indexOf("javascript") >= 0 ? getState(time).val : time;
var v = getDateObject(dateString);
return v.getHours() * 60 + v.getMinutes();
}
function getTimeDifference (time1, time2) {
return getMinutes(time1) - getMinutes(time2)
}
function getTimeStep (time1, time2, runs) {
return Math.round(((getState(time1).val - getState(time2).val) / runs) * 10) / 10;
}
function getKelvinState () {
return getState(DYNAMIC_LIGHT).val;
}
function setKelvin (value) {
return setState(DYNAMIC_LIGHT, value);
}
function setKelvinState (state) {
setKelvin(getState(state).val);
}
function setStartKelvinState () {
var state
switch (getState(ASTRO_DAYTIME).val) {
case 'Morgendämmerung':
state = KELVIN_DAYBREAK;
break;
case 'Sonnenaufgang':
state = KELVIN_SUNRISE;
break;
case 'Vormittag':
state = KELVIN_FORENOON;
break;
case 'Mittag':
state = KELVIN_NOON;
break;
case 'Abend':
state = KELVIN_EVE;
break;
case 'Nacht':
state = KELVIN_NIGHT;
break;
case 'Abenddämmerung':
state = KELVIN_TWILIGHT;
break;
}
if (state) {
setKelvinState(state);
}
}
function proveDaytime (obj) {
var runs, step;
console.log('ASTRO_DAYTIME: ' + obj.state.val)
switch (obj.state.val) {
case 'Morgendämmerung':
runs = getTimeDifference("javascript.0.Astro.Zeiten.12 - dawn", "javascript.0.Astro.Zeiten.11 - nauticalDawn");
step = getTimeStep(KELVIN_SUNRISE, KELVIN_DAYBREAK, runs);
setKelvinState(KELVIN_DAYBREAK);
break;
case 'Sonnenaufgang':
runs = getTimeDifference("javascript.0.Astro.Zeiten.03 - goldenHourEnd", "javascript.0.Astro.Zeiten.12 - dawn");
step = getTimeStep(KELVIN_FORENOON, KELVIN_SUNRISE, runs);
setKelvinState(KELVIN_SUNRISE);
break;
case 'Vormittag':
runs = getTimeDifference("javascript.0.Astro.Zeiten.04 - solarNoon", "javascript.0.Astro.Zeiten.03 - goldenHourEnd");
step = getTimeStep(KELVIN_NOON, KELVIN_FORENOON, runs);
setKelvinState(KELVIN_FORENOON);
break;
case 'Mittag':
runs = getTimeDifference("javascript.0.Astro.Zeiten.05 - goldenHour", "javascript.0.Astro.Zeiten.04 - solarNoon");
step = getTimeStep(KELVIN_EVE, KELVIN_NOON, runs);
setKelvinState(KELVIN_NOON);
break;
case 'Abend':
runs = getTimeDifference("javascript.0.Astro.Zeiten.09 - nauticalDusk", "javascript.0.Astro.Zeiten.05 - goldenHour");
step = getTimeStep(KELVIN_TWILIGHT, KELVIN_EVE, runs);
setKelvinState(KELVIN_EVE);
break;
case 'Abenddämmerung':
runs = getTimeDifference("21:00", "javascript.0.Astro.Zeiten.09 - nauticalDusk");
step = getTimeStep(KELVIN_NIGHT, KELVIN_TWILIGHT, runs);
setKelvinState(KELVIN_TWILIGHT);
break;
default:
console.log('State missing: ' + obj.state.val)
break;
}
if (step && runs) {
startDimmer(step, runs);
}
}
/** ADD STATES **/
/***/
createState(KELVIN_DAYBREAK, {
name: 'Morgendämmerung',
unit: 'K',
type: 'number',
def: 2700,
});
createState(KELVIN_SUNRISE, {
name: 'Sonnenaufgang',
unit: 'K',
type: 'number',
def: 4000,
});
createState(KELVIN_FORENOON, {
name: 'Vormittag',
unit: 'K',
type: 'number',
def: 5500,
});
createState(KELVIN_NOON, {
name: 'Mittag',
unit: 'K',
type: 'number',
def: 5000,
});
createState(KELVIN_EVE, {
name: 'Abend',
unit: 'K',
type: 'number',
def: 4500,
});
createState(KELVIN_TWILIGHT, {
name: 'Abenddämmerung',
unit: 'K',
type: 'number',
def: 3000,
});
createState(KELVIN_NIGHT, {
name: 'Nacht',
unit: 'K',
type: 'number',
def: 2100,
});
createState(DYNAMIC_LIGHT, {
name: 'Hilfswert_Kelvin',
unit: 'K',
type: 'number',
def: 5000,
});
/***/
// Tageszeit überprüfen
on({ id: ASTRO_DAYTIME, change: "any" }, proveDaytime);
Astro Funktion
Finde leider nicht mehr die Quelle
const sec = false; // Sekunden darstellen oder nicht
const fC = false; // forceCreation ein/aus
const pfad = "Astro"; // Pfad zum Objekt - Objektbaum-Hauptverzeichnis
// *****************************************************************************
// TAGESZEITEN - T E I L
// Tageszeiten nach eigenem Gusto (Shifts siehe schedules weiter unten)
const tageszeiten = ["Nacht",
"Morgendämmerung",
"Sonnenaufgang",
"Morgen",
"Vormittag",
"Mittag",
"Nachmittag",
"Abend",
"Sonnenuntergang",
"Abenddämmerung"
];
const idTageszeit = "javascript." + instance + "." + pfad + ".Tageszeit.current" /*Tageszeit*/,
idTageszeitNext = "javascript." + instance + "." + pfad + ".Tageszeit.next";
createState(idTageszeit, "nächsten Wechsel abwarten", fC, {
name: "Tageszeit",
desc: "Name der Tageszeit",
type: "string"
});
createState(idTageszeitNext, "nächsten Wechsel abwarten", fC, {
name: "nächste Tageszeit",
desc: "Name der nächsten Tageszeit",
type: "string"
});
function neue_tageszeit(abschnitt) {
var akt = tageszeiten[parseInt(abschnitt, 10)],
// wenn aktuelles Element ist letztes, dann nächstes ist erstes :-D
nxt = (abschnitt + 1 === tageszeiten.length) ? tageszeiten[0] : tageszeiten[parseInt(abschnitt + 1, 10)];
setState(idTageszeit, akt);
setState(idTageszeitNext, nxt);
log("neue Tagezeit: " + akt);
log("nächte kommende Tagezeit: " + nxt);
}
// Nacht
schedule({
astro: "nauticalDusk",
shift: 45
}, function () {
neue_tageszeit(0);
});
// Morgengdämmerung
schedule({
astro: "nauticalDawn",
shift: -45
}, function () {
neue_tageszeit(1);
});
// Sonnenaufgang
schedule({
astro: "dawn"
}, function() {
neue_tageszeit(2);
});
// Morgen
schedule({
astro: "sunriseEnd"
}, function () {
neue_tageszeit(3);
});
// Vormittag
schedule({
astro: "goldenHourEnd",
shift: 60
}, function () {
neue_tageszeit(4);
});
// Mittag
schedule({
astro: "solarNoon",
shift: -30
}, function () {
neue_tageszeit(5);
});
// Nachmittag
schedule({
astro: "solarNoon",
shift: 30
}, function () {
neue_tageszeit(6);
});
// Abend
schedule({
astro: "goldenHour",
shift: -60
}, function () {
neue_tageszeit(7);
});
// Sonnenuntergang
schedule({
astro: "sunsetStart",
}, function () {
neue_tageszeit(8);
});
// Abenddämmerung (nach Sonnenuntergang)
schedule({
astro: "nauticalDusk"
}, function () {
neue_tageszeit(9);
});
// *****************************************************************************
// A S T O - T E I L
/* Objekt Astrotag
Astrotag liegt zwischen Sonnauf- und untergang,
Astronacht liegt zwischen Sonnenunter- und aufgang */
const idAstrotag = "javascript." + instance + "." + pfad + ".Astrotag";
// Objekt für Uhrzeiten der Astrozeiten
const astrotime = {
"elements" : [
// Astrotag beginnt
{
"fname" : "sunrise", // function name
"de" : {
"name" : "Sonnenaufgang",
"nxt" : "nächster",
"desc" : ""
},
"en" : {
"name" : "Sunrise",
"desc" : "top edge of the sun appears on the horizon"
},
"astroday" : true //during astroday
},
{
"fname" : "sunriseEnd", // function name
"de" : {
"name" : "Ende Sonnenaufgang",
"nxt" : "nächstes",
"desc" : ""
},
"en" : {
"name" : "End of sunrise",
"desc" : "bottom edge of the sun touches the horizon"
},
"astroday" : true //during astroday
},
{
"fname" : "goldenHourEnd", // function name
"de" : {
"name" : "Ende der goldenen Stunde am Morgen",
"nxt" : "nächstes",
"desc" : ""
},
"en" : {
"name" : "End of golden hour",
"desc" : "morning golden hour (soft light, best time for photography) ends"
},
"astroday" : true //during astroday
},
{
"fname" : "solarNoon", // function name
"de" : {
"name" : "Sonnenhöchststand",
"nxt" : "nächster",
"desc" : ""
},
"en" : {
"name" : "Solar noon",
"desc" : "sun is in the highest position"
},
"astroday" : true //during astroday
},
{
"fname" : "goldenHour", // function name
"de" : {
"name" : "Goldene Stunde (am Abend)",
"nxt" : "nächste",
"desc" : ""
},
"en" : {
"name" : "Golden hour",
"desc" : "evening golden hour starts"
},
"astroday" : true //during astroday
},
{
"fname" : "sunsetStart", // function name
"de" : {
"name" : "Beginn Sonnenuntergang",
"nxt" : "nächster",
"desc" : ""
},
"en" : {
"name" : "Sunset starts",
"desc" : "bottom edge of the sun touches the horizon"
},
"astroday" : true //during astroday
},
// Astronacht beginnt
{
"fname" : "sunset", // function name
"de" : {
"name" : "Sonnenuntergang",
"nxt" : "nächster",
"desc" : ""
},
"en" : {
"name" : "Sunset",
"desc" : "sun disappears below the horizon, evening civil twilight starts"
},
"astroday" : false //during astronight
},
{
"fname" : "dusk",
"de" : {
"name" : "Abenddämmerung",
"nxt" : "nächste",
"desc" : ""
},
"en" : {
"name" : "Dusk",
"desc" : "evening nautical twilight starts"
},
"astroday" : false //during astronight
},
{
"fname" : "nauticalDusk",
"de" : {
"name" : "nautische Abenddämmerung",
"nxt" : "nächste",
"desc" : ""
},
"en" : {
"name" : "Nautical dusk",
"desc" : "evening astronomical twilight starts"
},
"astroday" : false //during astronight
},
{
"fname" : "nadir",
"de" : {
"name" : "Nadir",
"nxt" : "nächster",
"desc" : "Fußpunkt gegenüber dem Zenit"
},
"en" : {
"name" : "Nadir",
"desc" : "darkest moment of the night, sun is in the lowest position"
},
"astroday" : false //during astronight
},
{
"fname" : "nauticalDawn",
"de" : {
"name" : "nautische Morgendämmerung",
"nxt" : "nächste",
"desc" : ""
},
"en" : {
"name" : "Nautical dawn",
"desc" : "morning nautical twilight starts"
},
"astroday" : false //during astronight
},
{
"fname" : "dawn",
"de" : {
"name" : "Morgendämmerung",
"nxt" : "nächste",
"desc" : ""
},
"en" : {
"name" : "dawn",
"desc" : "morning nautical twilight ends, morning civil twilight starts"
},
"astroday" : false //during astronight
}
]
};
function writeAstroTimes(i) {
// führende Nummer zur Sortierung in Admin/Objekte
var nr = (i+1 < 10) ? "0" + (i+1) : (i+1);
// Erstelle Objekt, falls nicht bereits vorhanden
var idAstroObject = "javascript." + instance + "." + pfad + ".Zeiten." + nr + " - " + astrotime.elements[i].fname;
createState(idAstroObject, " ", fC, {
name: astrotime.elements[i].de.nxt + " " + astrotime.elements[i].de.name + " Uhrzeit",
desc: astrotime.elements[i].en.desc,
type: "string"
});
setTimeout(function() { // kurz warten, damit Objekte ggf. erst angelgt werden können
var astrotag = getState(idAstrotag).val,
temp;
var today = new Date();
var tomorrow = new Date(today.setDate(today.getDate()+1));
var next_event;
if (astrotag) {
// Wenn Tag (Aufgang vorbei (erst wieder morgen, Untergang kommt noch heute)
next_event = (astrotime.elements[i].astroday) ? tomorrow : today; // prüfen
} else {
// nach Nacht (Untergang vorbei (erst wieder morgen, Aufgang kommt heute oder morgen)
next_event = (astrotime.elements[i].astroday) ? today : tomorrow; // prüfen
}
var fname = astrotime.elements[i].fname;
temp = getAstroDate(fname, next_event);
setState(idAstroObject, checkSec(temp.toLocaleTimeString('de-DE', { hour12: false })) );
}, 3 * 1000);
}
// Zeit mit oder ohne Sekunden anzeigen
function checkSec (zeit) {
if (!sec) {
var newString_arr = zeit.split(":");
var newString = newString_arr[0] + ":" + newString_arr[1];
return (newString);
} else return (zeit);
}
function getAstroday() {
// Astrotag bestimmen (boolean)
createState(idAstrotag, false, fC, {
type: "boolean",
name: "Astrologischer Tag",
desc: "Liegt die aktuelle Zeit zwischen Sonnenauf- und untergang"
});
setState(idAstrotag, isAstroDay());
}
function iterateAstrotimes() {
// Zeiten für jede Astrozeit schreiben
for (var i = 0; i < astrotime.elements.length; i++) {
writeAstroTimes(i);
}
}
// Astrotag checken
schedule("*/1 * * * *", function () { // jede Minute
getAstroday();
iterateAstrotimes();
});
iterateAstrotimes();
getAstroday();
