Beiträge von Viedotraum

Oder etwas Smarter mit Callback in der Funktion und Error Handling.

function readTemperatureSensor(callback) {
 Shelly.call(
   "HTTP.GET",
   { url: "http://192.168.178.70/rpc/Temperature.GetStatus?id=100" },
   function (result, error_code, error_message) {
     if (error_code !== 0) {
       callback(null, error_message); // Fehler an den Callback weitergeben
     } else {
       try {
         let jsonData = JSON.parse(result.body);
         callback(jsonData.tC, null); // Erfolg an den Callback weitergeben
       } catch (e) {
         callback(null, "JSON-Parsing-Fehler: " + e.message); // Parsing-Fehler
       }
     }
   }
 );
}

// -- Call Read Temperatur ---
readTemperatureSensor(function (myTemp, error_message) {
 if (error_message) {
   print("Fehler: " + error_message);
 } else {
   print("Die Zimmertemperatur ist: " + myTemp + " °C");
 }
});

Ok. Mein Fehler. Zur Erklärung:
Das mit dem Return funktioniert hier nicht, da es sich um ein asynchrones Script handelt.
Das heist, das die Funktion hinter dem Shelly.call(... Befehl asynchron zum rest des Codes verhält.
Es wird nämlich gewartet bis die Daten Empfangen werden und dann verarbeitet.
Da das aber Zeit kostet wird der restliche Code weiter ausgeführt. Der letzte Print Befehl
Wird schneller ausgeführt als der Rückgabewert verarbeitet wurde.

Das sieht man auch im Log:

Erst Undefiniert

Dann der Temp wert vom Print in der Shelly.call(... Funktion.

Besser man ruft einfach nach dem Lesen wieder eine Funktion auf die die Daten übermittelt.

function readTemperaturSensor() {
   //print ("readTemperaturSensor...");
   Shelly.call(
   "HTTP.GET",
   { url: "http://192.168.178.70/rpc/Temperature.GetStatus?id=100" },  // IP von Shelly mit AddOn
   function(result, error_code, error_message) {
     if (error_code !== 0) {
       print('Error');
     } else {
       let jsonData = JSON.parse(result.body);
       let tempHome = jsonData.tC;
       ausgabe(tempHome); // Call Funktion
     }
   });
 }
 
 function ausgabe(myTemp) {
   print("Die Zimmertemperatur ist: " + myTemp + " °C");
 }

// --- Starte Script:
readTemperaturSensor();

Hast du die ID bei dir überprüft. Ist sie wirklich 100?

{ url: "http://192.168.178.155/rpc/Temperature.GetStatus?id=100" },

Oder per Script abfragen:

function openMetroRead() {
  Shelly.call(
    "HTTP.GET",
    {
      url: "https://api.open-meteo.com/v1/forecast?latitude=00.0000&longitude=0.0000&daily=sunrise,sunset,temperature_2m_max&timezone=Europe%2FBerlin&forecast_days=1"
    },
    function(result, error_code, error_message) {
      if (error_code !== 0) {
        console.log('Fehler:', error_message);
      } else {
        let response = JSON.parse(result.body);
        DATA.sunrise = response.daily.sunrise[0].split("T")[1];
        DATA.sunset = response.daily.sunset[0].split("T")[1];
        DATA.maxTemperature = Number(response.daily.temperature_2m_max[0]);
        
        print("Sunrise: ", DATA.sunrise, " Sunset: ", DATA.sunset, " Max Temperature: ", DATA.maxTemperature, "°C");
        DATA.newDay = true;
      }
    }
  );
}

openMetroRead()

latitude=00.0000&longitude=0.0000

Deine Position kannst du über die Seite: https://www.gpskoordinaten.de/karte/land/DE
ermitteln.

Über die Seite kommst du auf die API.
https://open-meteo.com/en/docs#latitu…forecast_days=1

Dein Script stammt aus ChatGPT . Mit dem Http Call wird das nicht funktionieren.

Ein Korrekter Call wäre z.B. :

url: "http://localhost/relay/0?turn=on&timer=180"}, // 3 Min = 180 sec.

Meines Wissens ist es nicht möglich einfach per Http Befehl Daten ein anderen Shelly zu senden.

Zitat von AlexAn

Wenn man das gleiche Script in einen virtuellen Eingang/Components 20x schreiben könnte wäre das per Action auch im anderen Shelly nutzbar.

AlexAn

ich Denke das sollte funktionieren, Ich habe mich aber noch nicht an das Thema Scripting & Components beschäftigt.
Da die API sagt, das noch alles in Beta ist und sich die API noch ändern kann oder wird.
Wäre schlecht wenn eine Update erfolgt und das Script dann nicht mehr funktioniert.
Auch sei erwähnt, das Components nur bei den neuen Gen3 oder Gen2 Pro Geräten möglich ist.

Ein einfaches Beispiel:

function ichBinEineFunktionMitRueckgabe() {
  let temp = 60; // Die Variable wird 60 zugewiesen
  return temp;
}

// Aufruf der Funktion:
let wieIstTemp = ichBinEineFunktionMitRueckgabe();
print("Die Temperatur ist: " + wieIstTemp + " °C");

Um die Funktion aufzurufen musst du nach der function definition ein Aufruf schreiben.

let wieIstTemp = ichBinEineFunktionMitRueckgabe();

--------------

Shelly A mit dem AddOn + Temperaturfühler hat die IP 192.168.178.155
Der Shelly B hat die IP 192.168.178.150

Auf Shelly B wird das Script Ausgeführt. Das Script Besteht aus einer Funktion -> function {...}. wie das einfache Beispiel Script.
Über die URL werden die Daten vom Shelly A am AddOn ausgelesen -> Rückgabe ist ein JSON Datei.
Aus der wird dann die Temperatur extrahiert.

Die Funktion hat außerdem ein return Aufruf: Der gibt dir den Wert, in diesem Fall Temp als Zahl zurück. Wie das einfache Beispiel Script.

Wenn du nun auf Shelly B die Temperatur auf Shelly A abfragen willst musst du unter der function

den Aufruf ausführen.

let myTemp = readTemperaturSensor();

myTemp enthält nun den Temp Wert.

Das Script nochmal alles zusammen:

function readTemperaturSensor() {
   //print ("readTemperaturSensor...");
   Shelly.call(
   "HTTP.GET",
   { url: "http://192.168.178.155/rpc/Temperature.GetStatus?id=100" },  // IP von Shelly mit AddOn
   function(result, error_code, error_message) {
     if (error_code !== 0) {
       print('Error');
     } else {
       let jsonData = JSON.parse(result.body);
       let tempHome = jsonData.tC;
       //print ("Temp Home: " ,tempHome);
       
      return tempHome; // <--- RÜCKGABE <----
      
     }
   });
 }
 
 let myTemp = readTemperaturSensor(); // Funktion aufrufen mit Rückgabewert
 print("Die Zimmertemperatur ist: " + myTemp + " °C");

Der Aufruf sollte sich mit:
Shelly.call("HTTP.POST", { url: sendURL }, function()..
Per Script aufrufen lassen.

Ich verstehe die Frage nicht ganz. Was willst du genau erreichen?

Ja, das ist ein Shelly Script. Das ist ein Bestandteil meines Beschattung Scripts.
Bei mir hängt der Außenfühler mit am AddOn Shelly der auch das Garagentor steuert.
Da der Shelly eh draußen ist, habe ich auch gleich den Temperaturfühler mit angeschlossen.
Um die Temperatur jetzt für die Beschattung der beiden nach Westen ausgerichteten
Fester zu steuern frage ich den Shelly per Script ab.
Ich steuere die Beschattung nach Außentemperatur, Sonnenschein über Helligkeit (Photosensor)
und aktuelle Wetterdaten aus dem Internet. Dadurch bekomme ich Daten wie Bewölkung und
die tägliche Sonnenuntergangszeit.
Daraus errechne ich die Beschattung. Ich will ja im Winter die Sonneneinstrahlung haben, aber
im Sommer nicht. Das Script ist sehr umfangreich geworden, aber es Steuert die Rollos zuverlässig.

Einfaches Script zum auslesen vom Temperatur Sensor am AddOn von einem anderen Shelly.

function readTemperaturSensor() {
   //print ("readTemperaturSensor...");
   Shelly.call(
   "HTTP.GET",
   { url: "http://192.168.178.155/rpc/Temperature.GetStatus?id=100" },    
   function(result, error_code, error_message) {
     if (error_code !== 0) {
       print('Error');
     } else {
       let jsonData = JSON.parse(result.body);
       let tempHome = jsonData.tC;
       //print ("Temp Home: " ,tempHome);
      return tempHome;
     }
   });
 }

Bei der ID "id=100" in der URL musst du deine ID nehmen sowie die IP vom Shelly mit dem AddOn.

Call:
let myTemp = readTemperaturSensor();

Willst du das Script auf dem Shelly mit dem AddOn benutzen musst du die IP in der URL auf 127.0.0.1 setzen.
 { url: "http://127.0.0.1/rpc/Temperature.GetStatus?id=100" }, 

http://192.168.62.17/rpc/script.eval?id=2&code="htTest(${ev.tC})"

Wenn dein Action auf ein Script verweist das auf dem selben Device ist, darf die IP nicht von sich selbst sein.
Dann muss die IP: 127.0.0.1 genommen werden.

Vielleicht hilft dir diese Code als Beispiel weiter:
Shelly mit der IP: 192.168.178.150

var coverState = null; // Globale Variable zum Speichern des Cover-Zustands
const allowedStates = ["closing", "opening", "open", "close","stopped"]; // Liste der erlaubten Zustände

// Script auf Shelly mit der sendIP Addresse: Nr. 0 bis 2 ----> 0 = Cover L | 1 = Cover VL + VR | 2 = Cover R
const indexCoverInDictionary = "1"; // = Cover VL + VR sendet

const sendIP = "192.168.178.161";
const scriptPath = "script/3";

Shelly.addEventHandler(function (event) {
  if (event.name === "cover") {
    let newState = event.info.event; // Neuer Zustand des Covers
    
    // Überprüfen, ob der neue Zustand in der Liste der erlaubten Werte ist
    if (allowedStates.indexOf(newState) !== -1) {
      // Nur speichern, wenn der Zustand sich geändert hat
      if (coverState !== newState) {
        coverState = newState; // Zustand in globale Variable speichern
        print("Cover hat sich geändert. Neuer Zustand: " + newState);
        
        // Sende zu Register.Endpoint -> 0 = Rastore L 
        Shelly.call("HTTP.REQUEST", {
          method: "GET",
          url: "http://" + sendIP + "/" + scriptPath + "/raffstoresZustand?" + indexCoverInDictionary + ":" + newState
          });
      } 
    } 
  }
});

Empfänger:
Shelly IP: 192.168.178.161
Script 3

const ENDPOINT = {
  allowedStates: ["closing", "opening", "open", "close","stopped"],
}

HTTPServer.registerEndpoint('raffstoresZustand', function (req, res) {
  let resultArray = req.query.trim().split(":");
  print ("resultArray: " + resultArray);
  if (ENDPOINT.allowedStates.indexOf(resultArray[1]) !== -1) {
  
    print("Anfrage erhalten. Handler für 'raffstoresZustand' aufgerufen. -> req.query: " + req.query); 
    
    // z.B. Jetzt eine Function aufrufen um seinen Code auszuführen....
    
    // Melde das es Empfangen wurde...
    res.body = "Shelly Webserver: " + req.query;
    res.code = 200;
    res.send();
  }
});

Das Erste Script (IP: 192.168.178.150) abonniert den EventHandler wenn sich der Zustand des Covers ändert. Also betätigt wird.

Wenn das nach den abgefragten Kriterien erfüllt ist, wird den anderen Shelly (192.168.178.161) per Register.Endpoint ein String zugesandt:

Wichtig beim ersten Script ist eigentlich nur das Senden:

Shelly.call("HTTP.REQUEST", {
          method: "GET",
          url: "http://" + sendIP + "/" + scriptPath + "/raffstoresZustand?" + indexCoverInDictionary + ":" + newState
          });

Der Empfänger abonniert dann 'raffstoresZustand' und wartet darauf bis etwas gesendet wird.

Empfängt HTTPServer.registerEndpoint('raffstoresZustand' was wird die function ausgeführt.

INFO: Es ist nicht nötig den registerEndpoint in einer Timer Schleife zu setzen. der Code wird ausgeführt sobald was empfangen wird.

So kann man über zwei verschiedene Shelly´s Daten austauschen.

Das geht auch mit mehreren Shelly´s die auf dem selben Register.Endpoint senden.

Als Übertragung habe ich "1:open" gewählt.

Der String wird dann beim Empfänger aufgeschnitten "1" und "open" -> so kann ich auswerten welcher Shelly gesendet hat, in diesem Beispiel "1" und als Daten = "open"

Ja, das ist möglich. Gehe per IP auf den Shelly, -> Menü Scripts. Gebe oben dem Script einen Namen und speichere es. Z.B. "log".
Dann das Script anklicken und im Fenster unten in der Console -> auf > Websocket debug logs are disabled < Enable klicken.
Als letztes, oben rechts in der Console den Hacken "Only script logs" ausschalten.

Nun einmal den Shelly per App oder Taster ansteuern und schon wird in der Console alle Informationen angezeigt.

Habe die Kombi (2PM Gen3 + AddOn) im Einsatz. Funktioniert!

Über den Voltmeter Eingang lassen sich auch andere Komponenten anschließen.
Der Shelly Uni Plus verfügt ausserdem noch über einen Impulseingang.

Erkläre mal genauer was du vorhast. Willst du per Script auf die Daten zugreifen und sie verarbeiten?
Evtl. per HTTPServer.registerEndpoint an einen anderen Shelly senden und empfangen?
Wenn der Sensor am Uni Plus korrekt angezeigt wird ist das per Script machbar.

Hast du den Haken im Slat Control Menü bei Retrain Slat Position gesetzt? Wenn ja, ist das verhalten so korrekt. Es wird immer die Slat Pos. vom der letzten Position wieder gesetzt nach der Auf oder Abfahrt.

Ich denke das du noch "alte" Raffstores hast. Die Beim Hochfahren sich komplett umdrehen? Neuere machen das nicht. Sie kippen die Lamellen immer nur zu einer Richtung. Von Wagerecht zu Senkrecht. Egal ob hoch oder runter gefahren wird. Solltest versuchen in den Slat Pos Einstellungen die Zeiten von Auf nach Zu und von zu nach auf unterschiedlich einzustellen. Bei mir waren die vorgegebenen 1,5 Sekunden zu lang.

Thema

Shelly 2PM Gen3 - Raffstore Scripting Steuerung - examples

Für alle die sich mit dem Thema Raffstore Beschattung und Steuerung beschäftigen, werde ich hier mein Script examples mit euch teilen.
Da der Shelly 2PM Gen3 ganz neu auf dem Markt ist und das Scripting sich von den anderen unterscheidet, wird es vielleicht dem ein oder anderen eine Hilfe sein, die Raffstore per Script zu steuern.

Vorraussetzungen: Shelly 2PM Gen3 ist auf Cover eingerichtet und die Raffstore sind kalibriert worden.

(Quelltext, 13 Zeilen)

Ich habe die Variante "localhost"…

Viedotraum

10. November 2024 um 19:23