Beiträge von Maik S.

// Configuration
var powerLimit = 10; // Set your threshold here
// Initialization
Shelly.call("Switch.Set", {id: 0, on: true}); // Turn on Channel 1 at startup
// Event handler function
function handleEvent(event) {
   // The 'event' argument contains the event data sent by the Shelly devices.
   //print(JSON.stringify(event));
   // Check if "Switch:0" exists in the event
   if (event.info.id === 0) 
   {
      
      var power = event.info.apower; // Get the power consumption
      if(typeof power !== "undefined")
      {
         // Check if the power consumption is above the threshold
         if (power > powerLimit) 
         {
             // If the power consumption is above the threshold, turn on Channel 2
             // This could be, for example, a fan that cools down the device connected to Channel 1
             Shelly.call("Switch.Set", {id: 1, on: true}); //this Function turns on the Channel 2
         } 
         else 
         {
             // If the power consumption is below the threshold, turn off Channel 2
             // This means the device connected to Channel 1 is not consuming much power, so the fan can be turned off
             Shelly.call("Switch.Set", {id: 1, on: false}); //this Function turns off the Channel 2
         }
      }
   } 
}

// Register the event handler
// The 'handleEvent' function will be called automatically whenever an event occurs (e.g., when the state of a device changes or when new power data is available)
Shelly.addEventHandler(handleEvent);

let ShellyIP = '192.168.1.2';    //IP-Adresse des Shellys, an dem das Licht angeschlossen ist
let TimerDauerlicht = 10;        // Zeit die das Dauerlicht maximal an sein darf
let TimerDauerwert = "m";        // Wert für TimerDauerlicht (s=Sekunden, m=Minuten)
let dimState = 35;               // Prozent Dimmerhelligkeit 
let SWINT = true;                /* Wert für die funktion des internen Tasters 
                                 (Wichtig, falls ein Taster oder Schalter an diesem Gerät angeschlossen ist, 
                                 der nicht den Dimmer schalten soll, muss der Wert auf "false" stehen!)*/
let SWID = 0;                    //TasterID (Muss nur angepasst werden, wenn der Taster an diesem Gerät und nicht am SW1 angeschlossen ist)
let ZeitNacht = "21:30";         // Uhrzeit für den Nachtmodus
let ZeitTag = "06:00";           // Uhrzeit für den Tagmodus
let DimNacht = 40;               // Helligkeit bei Nachtmodus
let DimTag = 45;                 // Helligkeit bei Tagmodus
let BMTimer = 50;                // Zeitdauer für den Bewegungsmelder
let BMTimerWert = 's';           // Einheit für BMTimer (s=Sekunden, m=Minuten)
let debug = false;               // wenn true dann sende Ausgaben für Debug-Infos
/***************************************************************
*                                                              *
*     Ab dieser Position Bitte nichts mehr ändern!             *
*                                                              *
****************************************************************/
// Funktion zum Umrechnen der Uhrzeit in Minuten seit Mitternacht
function timeToMinutes(time) 
{
 let parts = time.split(':');
 let stunden = Number(parts[0]);
 let minuten = Number(parts[1]);
 return stunden * 60 + minuten;
}
let nachtZeit = timeToMinutes(ZeitNacht);
let tagZeit = timeToMinutes(ZeitTag);
//Funktion zur Einstellung der Helligkeit im Tag- bzw. Nachtmodus
function adjustBrightness() {
 let jetzt = new Date();
 let stunden = jetzt.getHours();
 let minuten = jetzt.getMinutes();
 // Konvertiere die aktuelle Uhrzeit in Minuten seit Mitternacht
 let aktuelleZeit = stunden * 60 + minuten;
 if (aktuelleZeit >= nachtZeit || aktuelleZeit < tagZeit) {
   // Wenn es nach der Nachtzeit oder vor der Tagzeit ist, setze die Helligkeit auf DimNacht
   //setLightBrightness(ip, DimNacht);
   dimState = DimNacht;
   dPrint("Nachtmodus ist aktiv, Helligkeit ist bei " + DimNacht + "%");
 } else {
   // Ansonsten setze die Helligkeit auf DimTag
   //setLightBrightness(ip, DimTag);
   dimState = DimTag;
   dPrint("Tagmodus ist aktiv, Helligkeit ist bei " + DimTag + "%");
 }
}
// Funktion zum Umrechnen der Zeit in Millisekunden
function calcTime(timer, value){
 let msec;
 if(value === "s") {
   msec = timer*1000;
 } else {
   msec = timer*60*1000;
 }
 return msec;
}

let SWTimer; // Variable für den Taster-Timer
let BMTimer; // Variable für den Bewegungsmelder-Timer
let SWtimerAktiv = false; // Variable, um den Status des Taster-Timers zu speichern
let BMtimerAktiv = false; // Variable, um den Status des Bewegungsmelder-Timers zu speichern
let bmZeit = calcTime(BMTimer, BMTimerWert); // Zeitdauer Bewegungsmelder in Millisekunden
let TDL = calcTime(TimerDauerlicht, TimerDauerwert); // Zeitdauer Taster in Millisekunden
//Funktion zur Überprüfung des Lichtes, wenn der Taster gedrückt wurde (Wenn Aus, dann an und umgekehrt nur aus wenn über Taster angeschaltet wurde)
function handleButtonPress(ip,DoublePress) {
 adjustBrightness(); //reguliert den Tag- und Nachtmodus 
 isLightOn(ip, function(isOn) {
   if (SWtimerAktiv && DoublePress === false) {
     // Wenn das Licht durch den Taster eingeschaltet wurde, schalte es aus und setze SWtimerAktiv auf false
     Timer.clear(SWTimer); //löscht den Timer
     setLightBrightness(ip, dimState); //ändert die Helligkeit auf dimState (Wichtig: vor allem wenn das licht bei 100% ist, damit der BM wieder im gedimmten Modus einschaltet)
     setLightBrightness(ip, 0); //(schaltet das Licht aus)
     SWtimerAktiv = false; //Damit wird der BM wieder freigegeben
     // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
     dPrint('Taster wurde 1x gedrückt: Licht wurde zuvor über den Taster eingeschaltet und wird daher jetzt Ausgeschaltet');
   } else {
     // Wenn das Licht aus ist oder durch den Bewegungsmelder eingeschaltet wurde, schalte es ein, starte den Timer und setze SWtimerAktiv auf true
     if (DoublePress===false)
     {
       setLightBrightness(ip, dimState); //schaltet das Licht im gedimmten Modus ein
       // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
       dPrint('Taster wurde 1x gedrückt: Licht wurde zuvor über nicht den Taster eingeschaltet und wird daher jetzt eingeschaltet');
     }
     else
     {
       setLightBrightness(ip, 100); //schaltet das Licht auf voller Last ein
       // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
       dPrint('Taster wurde 2x gedrückt: wird daher mit 100% Helligkeit eingeschaltet');
     }
     //Timer wird gestartet damit das Licht nicht ewig brennt, wenn vergessen wird, das Licht über den Taster auszuschalten
     SWTimer = Timer.set(TDL, false, function() 
     {
       setLightBrightness(ip, dimState); //ändert die Helligkeit auf dimState (Wichtig: vor allem wenn das licht bei 100% ist, damit der BM wieder im gedimmten Modus einschaltet)
       setLightBrightness(ip, 0); //(schaltet das Licht aus)
       SWtimerAktiv = false; //Damit wird der BM wieder freigegeben
       // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
       dPrint('Dauerlicht hat das Zeitlimit von '+ TDL + 'ms erreicht und wird jetzt ausgeschaltet');
     }, null);
     SWtimerAktiv = true; // Setze die Variable auf true, wenn das Licht eingeschaltet wird. Damit wird der BM gesperrt.
   }
 });
}

// Funktion zum Drucken von Debugging-Nachrichten
function dPrint(text){
 if(debug===true){
   print(text)
 }  
}
//Funktion zum einschalten des Lichtes mit der gesetzten Helligkeit 
function setLightBrightness(ip, brightness) {
 // Überprüfe, ob die Helligkeit größer als 0 ist
 if (brightness > 0) {
   // Wenn ja, schalte das Licht mit der angegebenen Helligkeit ein
   let url = 'http://' + ip + '/light/0?turn=on&brightness=' + brightness;
   Shelly.call("http.get", {url: url}, function (rs, ec, em) { }, null);
 } else {
   // Wenn nicht, schalte das Licht aus
   let url = 'http://' + ip + '/light/0?turn=off';
   Shelly.call("http.get", {url: url}, function (rs, ec, em) { }, null);
 }
}
//Funktion zur Überprufung, ob das Licht an- oder ausgeschaltet ist.
function isLightOn(ip, callback) {
 let url = 'http://' + ip + '/settings/light/0';
 Shelly.call("http.get", {url: url}, function (response, error_code, error_message, ud) { 
   let resBody = JSON.parse(response.body);
   if (resBody && typeof resBody.ison !== 'undefined') {
     callback(resBody.ison);
   } else {
     // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
     dPrint('Fehler beim Abrufen des Lichtstatus: ', error_code, error_message);
     callback(false);
   }
 }, null);
}
//Funktion zur Abfrage der HTTP-Get Parameter des Bewegungsmelders
function myCallback(optionalArg)
{
 if (optionalArg && optionalArg.query) 
 {
   //dPrint(optionalArg);
   let optArg= optionalArg.query;
   let ArgArray= getQueryParams(optArg);
 
   if (ArgArray.button === "BM" && ArgArray.push === "off") 
   {
     // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
     dPrint("Blindtime des Bewegungsmelders ist abgelaufen. Prüfe den Tasterstatus, ob weitere Aktionen notwendig sind...");
     isLightOn(ShellyIP, function(isOn) 
     {
       //dPrint("Licht ist an!");
       if (!SWtimerAktiv) 
       {
         BMtimerAktiv = true;
         // Wenn der Timer nicht aktiv ist, schalte das Licht ein und starte einen neuen Timer
         BMTimer = Timer.set(bmZeit, false, function() 
         { // Setze den Timer auf bmZeit
           adjustBrightness(); //reguliert den Tag- und Nachtmodus 
           setLightBrightness(ShellyIP, dimState); //ändert die Helligkeit auf dimState
           setLightBrightness(ShellyIP, 0); // schaltet das Licht aus
           // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
           dPrint("Es wurde keine weitere Bewegung registriert, und die Blindtime des Scriptes ist abgelaufen.");
           dPrint("Das Licht wurde ausgeschaltet.");
           BMtimerAktiv = false; 
         }, null);
         // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
         dPrint("Timer von "+ bmZeit +"ms wurde gestartet da Bewegungsmelder aus ist und keine Taste vorher gedrückt wurde");
       }
       else
       {
         // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
         dPrint("Licht wurde mit Taster aktiviert, der Bewegungsmelder darf nicht ausschalten!");
       }
     });
   }
   if (ArgArray.button === "BM" && ArgArray.push === "on")
   {
       dPrint("Bewegungsmelder wurde angeschaltet und Überprüfung, ob BMTimer aktiv ist, wird durchgeführt");
       if (BMtimerAktiv) 
       {
           Timer.clear(BMTimer);
           BMtimerAktiv = false;
           // Verwende die print Funktion, um eventuelle Fehler zu behandeln (debug muss auf true sein)
           dPrint("BMTimer war aktiv und wurde gelöscht");
       }
   }
   
   // Ausführung eines externen Tasters (wie z.B.: der Shelly Button1 oder ein Taster an einem anderen Shelly )
   if (ArgArray.button === "extbutton" && ArgArray.push === "single_push")
   {
     handleButtonPress(ShellyIP, false);
   }
   if (ArgArray.button === "extbutton" && ArgArray.push === "double_push")
   {
     handleButtonPress(ShellyIP, true);
   }
 }
}
// Registrierung des Endpunkts (myTrigger) für HTTP-Anfragen und Aufruf der Funktion myCallback
// Das heißt sobald das Script über die URL http://localhost/script/1/myTrigger?param1=value1&param2=value2&param3=value3
// aufgerufen wird, werden die Parameter (param1=value1&param2=value2&param3=value3) als String an die Funktion myCallback übergeben und bearbeitet
HTTPServer.registerEndpoint(
 "myTrigger",
 myCallback,
 "callback_arg"
);
// Funktion zum Parsen von Query-Parametern aus einer URL
// Beispiel: Aus "http://localhost/script/1/myTrigger?param1=value1&param2=value2&param3=value3"
// wird ein Objekt erstellt: {"param1": "value1","param2": "value2","param3": "value3"}
function getQueryParams(str) 
{
 let result = {}; // Ein leeres Objekt wird erstellt, um die Parameter und ihre Werte zu speichern
 let params = str.split('&'); // Die Eingabezeichenkette wird an jedem '&' aufgeteilt, um ein Array von Parametern zu erstellen
                              // Beispiel: Aus "param1=value1&param2=value2&param3=value3" wird 
                              // ["param1=value1", "param2=value2", "param3=value3"]
 // in der folgenden Schleife werden die Paramerter mit Namen und deren Wert in das Objekt eingetragen 
 params.forEach(function(param) 
 {
   let paramParts = param.split('='); // Der Parameter wird an '=' aufgeteilt, um den Namen und den Wert des Parameters zu extrahieren
   result[paramParts[0]] = paramParts[1]; // Der Parametername wird als Schlüssel und der Parameterwert als Wert zum Ergebnisobjekt hinzugefügt
 });
 return result; // Das Ergebnisobjekt, das die Parameter und ihre Werte enthält, wird zurückgegeben
}

//Funktion zur Überprüfung diverser Aktionen des Shelly I4 (in diesem Falle die Überprüfung, wie der Taster gedrückt wurde und was in dem Falle getan werden soll)
Shelly.addEventHandler(
 function (event, user_data) 
 {
   if (typeof event.info.event !== 'undefined' && SWINT === true) 
   {
     if (event.info.id === SWID && event.info.event === 'single_push') 
     {
       handleButtonPress(ShellyIP,false); 
     }
     else if (event.info.id === SWID && event.info.event === 'double_push') 
     {
       handleButtonPress(ShellyIP,true);
     }
   }
 }
);

let ShellyIP = '192.168.0.52'; //IP-Adresse des Shellys, an dem das Licht angeschlossen ist
let TimerDauerlicht = 5; // Zeit die das Dauerlicht maximal an sein darf
let TimerDauerwert = "m"; // Wert für TimerDauerlicht (s=Sekunden, m=Minuten)
let dimState = 35; // Prozent Dimmer 
let SWID = 1; //TasterID
let ZeitNacht = "21:30"; // Uhrzeit für den Nachtmodus
let ZeitTag = "06:00"; // Uhrzeit für den Tagmodus
let DimNacht = 35; // Helligkeit bei Nachtmodus
let DimTag = 45; // Helligkeit bei Tagmodus
let BMTimer = 10; // Zeitdauer für den Bewegungsmelder
let BMTimerWert = 's'; // Einheit für BMTimer (s=Sekunden, m=Minuten)
let debug = false; // wenn true dann sende Ausgaben für Debug-Infos

// Funktion zum Umrechnen der Uhrzeit in Minuten seit Mitternacht
function timeToMinutes(time) {
 let parts = time.split(':');
 let stunden = Number(parts[0]);
 let minuten = Number(parts[1]);
 return stunden * 60 + minuten;
}
let nachtZeit = timeToMinutes(ZeitNacht);
let tagZeit = timeToMinutes(ZeitTag);
//Funktion zur Einstellung der Helligkeit im Tag- bzw. Nachtmodus
function adjustBrightness() {
 let jetzt = new Date();
 let stunden = jetzt.getHours();
 let minuten = jetzt.getMinutes();
 // Konvertiere die aktuelle Uhrzeit in Minuten seit Mitternacht
 let aktuelleZeit = stunden * 60 + minuten;
 if (aktuelleZeit >= nachtZeit || aktuelleZeit < tagZeit) {
   // Wenn es nach der Nachtzeit oder vor der Tagzeit ist, setze die Helligkeit auf DimNacht
   //setLightBrightness(ip, DimNacht);
   dimState = DimNacht;
   dPrint(DimNacht);
 } else {
   // Ansonsten setze die Helligkeit auf DimTag
   //setLightBrightness(ip, DimTag);
   dimState = DimTag;
   dPrint(DimTag);
 }
}
// Funktion zum Umrechnen der Zeit in Millisekunden
function calcTime(timer, value){
 let msec;
 if(value === "s") {
   msec = timer*1000;
 } else {
   msec = timer*60*1000;
 }
 return msec;
}

let SWTimer; // Variable für den Taster-Timer
let BMTimer; // Variable für den Bewegungsmelder-Timer
let SWtimerAktiv = false; // Variable, um den Status des Taster-Timers zu speichern
let BMtimerAktiv = false; // Variable, um den Status des Bewegungsmelder-Timers zu speichern
let bmZeit = calcTime(BMTimer, BMTimerWert); // Zeitdauer Bewegungsmelder in Millisekunden
let TDL = calcTime(TimerDauerlicht, TimerDauerwert); // Zeitdauer Taster in Millisekunden
//Funktion zum Überprüfung des Lichtes, wenn der Taster gedrückt wurde (Wenn Aus, dann an und umgekehrt)
function handleButtonPress(ip,DoublePress) {
 adjustBrightness();
 isLightOn(ip, function(isOn) {
   if (isOn && DoublePress===false) {
     // Wenn das Licht an ist, schalte es aus und stoppe den Timer
     Timer.clear(SWTimer);
     setLightBrightness(ip, dimState);
     setLightBrightness(ip, 0);
     SWtimerAktiv = false;
   } else {
     // Wenn das Licht aus ist, schalte es ein und starte den Timer
     if (DoublePress===false)
     {
       setLightBrightness(ip, dimState);
     }
     else
     {
       setLightBrightness(ip, 100);
     }
     SWTimer = Timer.set(TDL, false, function() 
     {
       setLightBrightness(ip, dimState);
       setLightBrightness(ip, 0);
     }, null);
     SWtimerAktiv = true;
   }
 });
}

// Funktion zum Drucken von Debugging-Nachrichten
function dPrint(text){
 if(debug===true){
   print(text)
 }  
}
//Funktion zum einschalten des Lichtes mit der gesetzten Helligkeit 
function setLightBrightness(ip, brightness) {
 // Überprüfe, ob die Helligkeit größer als 0 ist
 if (brightness > 0) {
   // Wenn ja, schalte das Licht ein und setzen Sie die Helligkeit
   let url = 'http://' + ip + '/light/0?turn=on&brightness=' + brightness;
   Shelly.call("http.get", {url: url}, function (rs, ec, em) { }, null);
 } else {
   // Wenn nicht, schalte das Licht aus
   let url = 'http://' + ip + '/light/0?turn=off';
   Shelly.call("http.get", {url: url}, function (rs, ec, em) { }, null);
 }
}
//Funktion zur Überprufung, ob das Licht an- oder ausgeschaltet ist.
function isLightOn(ip, callback) {
 let url = 'http://' + ip + '/settings/light/0';
 Shelly.call("http.get", {url: url}, function (response, error_code, error_message, ud) { 
   let resBody = JSON.parse(response.body);
   if (resBody && typeof resBody.ison !== 'undefined') {
     callback(resBody.ison);
   } else {
     // Verwende die print Funktion, um den Fehler zu behandeln
     dPrint('Fehler beim Abrufen des Lichtstatus: ', error_code, error_message);
     callback(false);
   }
 }, null);
}
//Funktion zur Abfrage der HTTP-Get Parameter des Bewegungsmelders
function myCallback(optionalArg)
{
 if (optionalArg && optionalArg.query) 
 {
   dPrint(optionalArg);
   let optArg= optionalArg.query;
   let ArgArray= getQueryParams(optArg);
 
   if (ArgArray.button === "BM" && ArgArray.push === "off") 
   {
     dPrint("Bewegungsmelder wurde ausgeschaltet");
     isLightOn(ShellyIP, function(isOn) 
     {
       dPrint("Licht ist an!");
       if (!SWtimerAktiv) 
       {
           BMtimerAktiv = true;
         // Wenn der Timer nicht aktiv ist, schalte das Licht ein und starte einen neuen Timer
         //setLightBrightness(ip, 100); // Setze die Helligkeit auf 100%
         BMTimer = Timer.set(bmZeit, false, function() 
         { // Setze den Timer auf bmZeit
           adjustBrightness();
           setLightBrightness(ShellyIP, dimState);
           setLightBrightness(ShellyIP, 0); // Schalte das Licht nach bmZeit aus
           BMtimerAktiv = false;
         }, null);
         
         dPrint("Timer von "+ bmZeit +"ms wurde gestartet da Bewegungsmelder aus ist und keine Taste vorher gedrückt wurde");
       }
       else
       {
         dPrint("Licht wurde mit Taster aktiviert, der Bewegungsmelder darf nicht ausschalten!");
       }
     });
   }
   if (ArgArray.button === "BM" && ArgArray.push === "on")
   {
       dPrint("Bewegungsmelder wurde angeschaltet und Überprüfung ob BMTimer aktiv wird durchgeführt");
       if (BMtimerAktiv) 
       {
           Timer.clear(BMTimer);
           BMtimerAktiv = false;
           dPrint("BMTimer war aktiv und wurde gelöscht");
       }
   }
 }
}
// Registrierung des Endpunkts (myTrigger) für HTTP-Anfragen und Aufruf der Funktion myCallback
// Das heißt sobald das Script über die URL http://<IP des Shellys in dem das Skript ist>/script/<Skript-ID>/myTrigger?param1=value1&param2=value2&param3=value3
// aufgerufen wird, werden die Parameter (param1=value1&param2=value2&param3=value3) als String an die Funktion myCallback übergeben und bearbeitet
HTTPServer.registerEndpoint(
 "myTrigger",
 myCallback,
 "callback_arg"
);
// Funktion zum Parsen von Query-Parametern aus einer URL
// Beispiel: Aus "http://<IP des Shellys in dem das Skript ist>/script/<Skript-ID>/myTrigger?param1=value1&param2=value2&param3=value3"
// wird ein Objekt erstellt: {"param1": "value1","param2": "value2","param3": "value3"}
function getQueryParams(str) 
{
 let result = {}; // Ein leeres Objekt wird erstellt, um die Parameter und ihre Werte zu speichern
 let params = str.split('&'); // Die Eingabezeichenkette wird an jedem '&' aufgeteilt, um ein Array von Parametern zu erstellen
                              // Beispiel: Aus "param1=value1&param2=value2&param3=value3" wird 
                              // ["param1=value1", "param2=value2", "param3=value3"]
 // in der folgenden Schleife werden die Paramerter mit Namen und deren Wert in das Objekt eingetragen 
 params.forEach(function(param) 
 {
   let paramParts = param.split('='); // Der Parameter wird an '=' aufgeteilt, um den Namen und den Wert des Parameters zu extrahieren
   result[paramParts[0]] = paramParts[1]; // Der Parametername wird als Schlüssel und der Parameterwert als Wert zum Ergebnisobjekt hinzugefügt
 });
 return result; // Das Ergebnisobjekt, das die Parameter und ihre Werte enthält, wird zurückgegeben
}

//Funktion zur Überprüfung diverser Aktionen des Shelly I4 (in diesem Falle die Überprüfung, wie der Taster gedrückt wurde und was in dem Falle getan werden soll)
Shelly.addEventHandler(
 function (event, user_data) 
 {
   if (typeof event.info.event !== 'undefined') 
   {
     if (event.info.id === SWID && event.info.event === 'single_push') 
     {
       handleButtonPress(ShellyIP,false); // Ersetzen Sie '192.168.0.46' durch die tatsächliche IP-Adresse Ihres Geräts
     }
     else if (event.info.id === SWID && event.info.event === 'double_push') 
     {
       handleButtonPress(ShellyIP,true);
     }
   }
 }
);

let SogliaTemp = 58.5; // Default value
function myCallback(optionalArg)
{
 // Check if optionalArg and its property 'query' exist
 if (optionalArg && optionalArg.query) 
 {
   // Store the value of optionalArg.query in the variable optArg
   let optArg = optionalArg.query;
   // Call the function getQueryParams with optArg as an argument and store the result in ArgArray
   let ArgArray = getQueryParams(optArg);
 
   // Check if the parameter "SogliaTemp" exists in ArgArray
   if (ArgArray.SogliaTemp) 
   {
     // Update the value of SogliaTemp with the passed value
     SogliaTemp = parseFloat(ArgArray.SogliaTemp);
   }
 }
}
// Registration of the endpoint for HTTP requests
HTTPServer.registerEndpoint(
 "myTrigger",
 myCallback,
 "callback_arg"
);
// Function for parsing query parameters from a URL
// Example: From "http://localhost/script/1/myTrigger?param1=value1&param2=value2&param3=value3"
// an object is created: {"param1": "value1", "param2": "value2", "param3": "value3"}
function getQueryParams(str) 
{
 let result = {}; // An empty object is created to store the parameters and their values
 let params = str.split('&'); // The input string is split at each '&' to create an array of parameters
                              // Example: From "param1=value1&param2=value2&param3=value3" becomes 
                              // ["param1=value1", "param2=value2", "param3=value3"]
 // In the following loop, parameters with names and their values are added to the object
 params.forEach(function(param) 
 {
   let paramParts = param.split('='); // The parameter is split at '=' to extract the name and value of the parameter
   result[paramParts[0]] = paramParts[1]; // The parameter name is added as the key, and the parameter value as the value to the result object
 });
 return result; // The result object containing the parameters and their values is returned
}
function Loop(){  
 
 try{      
     var TempH2O            = Shelly.getComponentStatus('Temperature', 100).tC;  //Lettura temperatura da addon
     if (TempH2O < SogliaTemp) {
       Shelly.call("Switch.Set", {"id": 0, "on": true});
       print("Output: ON");
     } else {
       Shelly.call("Switch.Set", {"id": 0, "on": false});
       print("Output: OFF");
     }
     
     print("")
 }catch(e){print(e);}
}
Timer.set(1000,true,Loop);

// 20220917, CH: got HTTPServer.registerEndpoint to run! :-)
// 20230507, DE: get Parameters from URL 
//
// Verified on a Shelly Plus 2PM
//  Firmware version: 0.14.1
//  Firmware build ID: 20230308-091102/0.14.1-g22a4cb7
//  Web build ID: 230302093842-767992a8-HEAD
//
// Trigger a method (function) in a script via browser by
//   - registering a name (endpoint) in a script
//   - requesting the endpoint and Parameters via web
//
//  As of now I use this method to write debug outputs to the console when needed.
//  I don't have my computer connected all the time so all debug output to the console is lost.
//  This way I can see all data on demand.
// 
//  Trigger the callback method via http://SHELLY_IP/script/SCRIPT_ID/myTrigger?what=ever&you=Want
//    replace
//    - SHELLY_IP with the IP of your shelly
//    - SCRIPT_ID with the ID of this script ->
//    use http://SHELLY_IP/rpc/Shelly.GetConfig in your browser and search for your script name
//    - If you change the name of the query parameter (in this Description what and you), then you must also change the object name from ArgArray ;)  
// 
// ** Don't forget to set the 'run on reboot' to enabled! **

// function triggered via web request

function myCallback(optionalArg){
let optArg= optionalArg.query;
let ArgArray= getQueryParams(optArg); //With the example from above, I would get ArgArray.what and ArgArray.you here.

print("Endpoint request received with optional argument: What=", ArgArray.what, "and you=", ArgArray.you); 
//With the example from above, I would get: Endpoint request received with optional argument: What= ever and you= Want

  // put here whatever you want to do
  //  - debug outputs
  //  - call other scripts
  //  - reboot
  //  - etc.
}

HTTPServer.registerEndpoint(
  "myTrigger",    // endpoint to be registered (and later called via browser)
  myCallback,     // method to be called when endpoint triggered via web
  "callback_arg"  // I don't get this to work but who cares? 
                  // I have no idea what to pass to my own method on an external call... *gg*
);

function getQueryParams(str) {
  let result = JSON.parse('{}');
  let params = [];
  let currentParam = "";

  for (let i = 0; i < str.length; i++) {
    if (str[i] === '&') {
      params.push(currentParam);
      currentParam = "";
    } else {
      currentParam += str[i];
    }
  }
  params.push(currentParam);

  for (let i = 0; i < params.length; i++) {
    let separatorIndex = -1;
    for (let j = 0; j < params[i].length; j++) {
      if (params[i][j] === '=') {
        separatorIndex = j;
        break;
      }
    }

    let name = "";
    let value = "";
    if (separatorIndex !== -1) {
      name = params[i].slice(0, separatorIndex);
      value = params[i].slice(separatorIndex + 1);
    }

    result[name] = value;
  }

  return result;
}

// This script runs for ever and does nothing but to wait for the webbrowser to come in.
// I get an 504 error in the browser but the script does what it is supposed to!

// ** Don't forget to set the 'run on reboot' to enabled! **