Beiträge von Viedotraum

Letzte Aktualisierung von Shelly ist der 24.10.23.

Hat einer von euch eine Alternative am laufen?
Copy - Paste funktioniert ja aus VSC.

Sonst werde ich es so machen.

Hat jemand Erfahrung mit Visual Studio Code und Shelly Scripting?
Habe den Shelly Script Editor installiert in VSC.
Konnte dann über die IP die Scripts laden.

Nur wenn auf dem Shelly sich ein größeres Script befindet, dann wird der Shelly mit der IP erst gar nicht geladen.
Der Shelly ist ein 2PM Gen3. Das Script hat ca. 800 Zeilen.

Gibt es eine Möglichkeit größere Scripts im Editor zu bearbeiten?
Habe ich bei der Einrichtung was übersehen?

Ich arbeite auf ein Mac mit M1.

Das Script ist direkt auf dem Shelly mit dem Script Editor problemlos editier und ausführbar.
Aber der Übersichtlichkeit würde ich gerne in VSC arbeiten.

Ja würde auch gehen aber ein Taster drücken nach dem auffüllen wäre das einfachste.
Habe das Script schon für den Counter reset von aktuellen Projekt.

Danke Erstmal an die vielen Tips von euch.

Mir ist beim grübeln noch etwas eingefallen. Da bei der Regeneration immer die gleiche Salzmenge verbraucht wird,
könnte man auch zählen, wieviel mal die Regeneration durchlaufen wurde, bis der Behälter leer ist.
Bei diesem Vorgang wird dem Behälter Wasser hinzugefügt. Dafür muss ja das verbaute Magnetventil schalten.

Einfache Rechnung: Z.B. 10x regenerieren = Behälter fast leer.
Der Shellly Uni Plus halt ja einen Impulseingang.
Der könnte einfach die Impulse Zählen wie oft das Magnetventil geschaltet wurde.
Auch wenn das bei der Regeneration mehrmals stattfindet, ist die Summer der Schaltvorgänge von voll bis leer immer gleich.

Noch ein kleinen Reset Taster einbauen -> Script schreiben -> fertig.

Ich habe bei meinem Beschattungs-Scripts über Homebridge mir in HomeKit Schalter erstellt die ich über das Shelly Script abfragen kann.
So kann man von "Außen" auf das Script einwirken. Vielleicht geht das auch bei HA.

Würde die von außen auch die Salztabletten messen können? Der Sole Pegel ist ja nicht ausschlaggebend.
Wenn regeneriert wird, wird dem Behälter Wasser hinzugefügt. Dann steigt der Pegel kurzzeitig.
Hat aber mit dem Verbrauch des Salzes nichts zu tun.

OK. Aber ich denke bevor die Sole ihre Leitfähigkeit verliert wäre ist es ja schon sehr leer der Behälter.
Ich habe noch etwas beim Recherchieren gefunden. Manche Hersteller messen wohl das Gewicht es Behälters. Auch eine Möglichkeit.
Wer Erfahrungen mit Ultraschall Sensoren die am Shelly Uni hat bitte mal Link oder was dazu schreiben. Digitale gehen wohl nicht.

Also die Leitfähigkeit in der Sole messen. Wenn alles Salz aufgebraucht ist und bei der Regenerierung neues Wasser hinzukommt,
aber kein Salz mehr gelöst wird, ist die Leitfähigkeit niedriger. Liege ich da richtig?
Das Befüllen mit Wasser von der Anlage würde aber Schwankungen in der Messung verursachen.
Aber das könnte man mit einem Script lösen. Wie gut das ich das kann.

Könnte funktionieren. Auch der Ultraschallmessung wäre eine Alternative.

Es ist eine Anlage von Aqmos. Da ich nicht viel verbrauche an Wasser hält die Befüllung relativ lange.
Ich habe hier >24 dH. Habe lange ohne Enthärtung gelebt. Aber der Verschleiß steht nicht mehr im Verhältnis.
Die Idee mit Ultraschall könnte funktionieren. Aber welches System benutzen denn die teuren Geräte. Z.B. Grünbeck.oder BWT?

Meine Anlage hat keine Anzeige. Dafür ist sie günstig und tut was sie soll. Das Wasser enthärten.

Hallo Michael.

Als ich mit dem Scripting auf dem Shelly angefangen habe, war ich auch auf Codebeispiele angewiesen.
Geben und nehmen, so sollte es sein.
Ich denke es hilft nicht nur dem einen, sondern der Community hier.

Ich gebe die von meine Aktuellen Projekt mal ein Test Script mit, das 24h in Schnelldurchlauf simuliert.

function TESTuhrzeit() {
  // Erhöhe die Minuten um 10
  TEST.minuten += 5;

  // Überprüfe, ob die Minuten 60 oder mehr sind und erhöhe die Stunden entsprechend
  if (TEST.minuten >= 60) {
    TEST.minuten -= 60;
    TEST.stunden += 1;

    // Optional: Zurücksetzen der Stunden bei 24 (24-Stunden-Format)
    if (TEST.stunden >= 24) {
      TEST.stunden = 0;
    }
  }
}

function TESTformatTime(stunden, minuten) {
  let hh = (TEST.stunden < 10 ? "0" : "") + TEST.stunden;
  let mm = (TEST.minuten < 10 ? "0" : "") + TEST.minuten;
  return hh + ":" + mm;
}

function readTime() {
  /*
  let now = new Date();
  let hours = now.getHours();
  let minutes = now.getMinutes(); 
  // Aktuelle Uhrzeit im Format "HH:MM"
  let currentTime = ("0" + hours).slice(-2) + ":" + ("0" + minutes).slice(-2);
  let month = now.getMonth() + 1;  // Aktueller Monat
  */
  TESTuhrzeit(); // Erstelle Test Uhrzeit
  let currentTime = TESTformatTime(); // TEST UHRZEIT RÜCKGABE
  return currentTime
}

Timer.set(200, true, function () { // Call jede Sekunde
  dayLoop(); // Call
});

function dayLoop() {
  let isTime = readTime();
  print (isTime)
}

Im Day Loop könnte man nun anfangen erstmal die isTime Uhrzeit abzufragen um eine Verzweigung zu erstellen um nur die Gewünschte Uhrzeit zu benutzen.
Dann erstmal Funktionen erstellen die die Abfrage der beiden Temp. Werte ermitteln mit Rückgabe.
Wenn ein AddOn benutzt wird dann kann man das mit diesem Script abfragen: Shelly AddOn auf anderem Shelly auslesen
Eine Funktion erstellen die die Relais dann ansteuern.
TempWerte vergleichen: temp < min -> Relais an / temp > max -> Relais off

Hast du Script Erfahrung?

Shelly.addEventHandler(..) sollte alle 4 Imputs in der JSON bei einem touch auffangen.
Daraus eine switch case Anweisung verzweigen.

        switch(event.info.id) {
          case 0:
            // Licht 1 an
            lichtAn(012,68);
            break;
           
          case 1:
            // Licht 2 an
            lichtAn(123,69);
            break;
           
          case 2:
            // Licht 3 an
            lichtAn(456,70);
            break;
           
          case 3:
            // Licht 4 an
            lichtAn(789,71);
            break;
           
          default:
            break;
        } 
        ...
function (id, group) {...}

Ich würde die
Shelly.call(  "http.request", {..}
in einer neuen Funktion auslagern und dann die spezifischen Werte darüber zu übergeben.

Das wäre ein einfaches Bespiel um Daten in einem Array zu sichern:

let history = [];

function logTemperature() {
   Shelly.call(
      "HTTP.GET",
      { url: "http://192.168.178.200/rpc/Temperature.GetStatus?id=100" },
      function (result, error_code, error_message) {
         if (error_code === 0) {
            let jsonData = JSON.parse(result.body);
            let temperature = jsonData.tC;
            let timestamp = Date();
            history.push({ time: timestamp, temp: temperature });

            // Wenn History 10 Einträge hat -> lösche History 
            if (history.length > 10) {
               // Jetzt die Datenn per HTTP senden...
               history = []; // dann löschen.
            }

            print("Temperature logged:", temperature, "at", timestamp);
         } else {
            print("Error reading temperature:", error_message);
         }
      }
   );
   print (history.length); // So viele Einträge hat die History jetzt.
}



// Timer: Testweise alle 2 Sekunden...
Timer.set(2000, true, logTemperature);

Mann müsste probieren wieviel Daten man per Http dann übertragen kann.
Ich benutze immer nur kleine Datenmengen.

Ja, da gebe ich dir recht. Bei den End Positionen sollte Slat Pos nicht ausgeführt werden. Auch wenn Retrain Slat Position gesetzt ist. Wenn man das will könnte man immer noch Close 5% anwählen und dann sollte Retrain Slat Position greifen.

Die History wird nicht im Shelly selbst gespeichert sonder in der Shelly Cloud.
Entweder man programmiert sich ein Array das die Daten per Script darin Speichert und nach x Tagen zurückgesetzt wird,
oder man greift per Script auf die Cloud Daten zu.

Bitte benutze immer beim Einfügen von Code -> Code-Block einfügen.
Dann ist dein Code viel besser lesbar.

Code:

Ja, natürlich. Aber ich denke du bist erst beim programmieren am Anfang.
Hier ein paar Tips die dich später nicht verzweifeln lassen.
Versuche immer einzelne Aktionen über Funktionen abzubilden.
Sie können entweder ein Wert berechnen mit Rückgabe oder etwas Schalten.
Der Sinn dahinter ist sie wiederverwendbar im Code zu machen.

Ein Beispiel Temperatur:

var tempHome;

function readTemperaturSensor() {
   // HTTP-Aufruf, um die Temperaturdaten abzurufen
   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) {
            print('Error beim Abrufen der Temperatur:', error_message);
         } else {
            let jsonData = JSON.parse(result.body);
            tempHome = jsonData.tC;
            print("Temp Home:", tempHome); // Temperatur wird hier korrekt ausgegeben
         }
      }
   );
}

function timerLoop() {
   readTemperaturSensor(); // Temperatur aktualisieren
   if (tempHome !== undefined) {
      print("Aktuelle Temperatur:" +  tempHome + " °C"); // Ausgabe der aktuellen Temperatur
      
      frostschutz(tempHome);
      // Hier könnten weitere function gestartet werden...
      
   } else {
      print("Temperatur ist noch nicht verfügbar.");
   }
   
}

function frostschutz(temp) { // 
  print ("Abfrage Frostschutz");
  // Ist temp < als Vorgabe ? = Lüfter An.
  if (temp < 1.5) { // Unter 1,5 °C ?
    ioLuefter(true);
  } else { // Größer = aus.
    ioLuefter(false);
  }
}

function ioLuefter(io) {
  if (io) { // Wenn io = true ist
     callOn()
     // Hier könnten noch weitere Aktionen gestartet werden.
  } else { // Wenn io false ist
     callOff()
     // Hier auch...
  }
}

function callOn() { // Die Funktion sollte nur den Aufruf für das Relais zum schalten haben.
  // HTTP aufruf --> Relais vom Shelly ON
  print("Lüfter Relais ON");
}

function callOff() { // Die Funktion sollte nur den Aufruf für das Relais zum schalten haben.
   // HTTP aufruf --> Relais vom Shelly OFF
   print("Lüfter Relais OFF");
}

// Timer einrichten: Wiederholung alle 1000 ms
Timer.set(1000, true, timerLoop);

Du siehst im Code das jede function eine Funktion hat. Entweder entscheidet sie was, oder führt was aus.
Ich habe den einfachen Temp lese Code wieder verwand. Da jetzt die Abfrage im Loop abläuft.
Im ersten Durchlauf ist die Temperatur noch nicht in der Globalen Variable var tempHome; gespeichert.
Beim 2. durchlauf liegt sie jetzt vor und kann verarbeitet werden.

Ja, Shelly zu Shelly mit AddOn. Um Daten abzufragen.

Hallo Forumsmitglieder,

hat jemand schon seine Enthärtungsanlage mit einem Shelly nachgerüstet der die Salzbehälterfüllung überwacht?
Meine Anlage ist sehr einfach aufgebaut und ich kann keine Kontakte abgreifen.
Mich würde interessieren mit welchen Sensor man Füllstand zuverlässig überwacht.
Also wann er fast leer ist.