Fehler bei Berechnungen

[Sefina]

Hi zusammen

Also bei dieser Berechnung sagt er mir "- cannot be resolved

sendCommand(Rollo0103, DauerRollo01*100/Rollo01Auf)
 sendCommand(Rollo0102, Rollo0102 - Rollo0103 ) 

In einem anderem Bereich "Typ mismatch: cannot convert from Numberitem to String

sendCommand(Rollo0103, DauerRollo01*100/Rollo01Auf)
 sendCommand(Rollo0102, Rollo0102 + Rollo0103 ) 

Bei beiden mache ich das gleiche :
Rollo0103 ist ein Numberitem was eine % Zahl wiedergibt was das Rollo gefahren ist. Diese wird in der Zeile darüber berechnet in einem 3 Satz
Diese muss ich jetzt einmal + einer Zahl oder - einer Zahl geben (je nach dem ob auf oder zu.

Die % Zahl wird richtig gerechnet aber dann ist schluss (

Habe es mit vielen Schreibweisen getestet .... kein Erfolg.

MfG

[udo1toni]

Wenn Du auf den Status eines Items zugreifen willst, musst Du das explizit angeben, also Item.state verwenden. Dann hast Du allerdings einen Status.
Du willst aber den Wert, der durch den Status repräsentiert wird, das bedeutet, Du musst den Wert noch casten, (Item.state as Number) wäre also der numerische Wert des Items.
Da Du den Wert in einem anderen Item speichern willst, musst Du auch noch aufpassen, wie Du das tust.
Es gibt zwei Möglichkeiten, einem Item einen Wert zuzuweisen, die Action und die Methode. Du verwendest die Action sendCommand(Item,Value). Die Action unterstützt per Definition ausschließlich Strings als Parameter, Du willst aber eine berechnete Zahl senden.
Das kann unerwarteter Weise funktionieren, weil openHAB vielleicht durch Zufall (weil die Berechnung ein Objekt erzeugt) nach String casten kann, oft genug entsteht aber kein Objekt sondern ein Primitive, dort gibt es keine Methode .toString, welche openHAB aufrufen könnte, deshalb geht die Action dann schief.
Wenn Du stattdessen die Methode Item.sendCommand(Value) verwendest, wird der numerische Wert zuverlässig korrekt übergeben, weil es für jeden möglichen Eingabetyp eine eigene Methode gibt, openHAB nimmt automatisch die am besten passende, dadurch klappt die Zuweisung dann.

[Sefina]

So nun rechnet er aber das Ergebnis ist totaler Mist

Rollo0103.sendCommand(DauerRollo01*100/Rollo01Zu)                              Rollo0102.sendCommand((Rollo0102.state as Number) + (Rollo0103.state as Number)) 

Die Berechnung der % funktioniert aber das - und + gehen nicht.

Beispiel :
ich fahre bei nem wert von 0% (auf) los und stope beim ersten 1/3 also ca. 33%
diese werden mir auch unter dem Item Rollo0103 angezeigt.
Nun soll er je nach dem wie die Fahrtrichtung ist + oder - rechnen hier ein +

also 0 + 33 = 33%

er sagt mir aber urplötzlich 10%

liegt es daran das ich Rollo0102 mit dem Item Rollo0102 berechne ?

MfG

[udo1toni]

Dein Code ist leider komplett kaputt. So kann man nichts erkennen...
Poste doch bitte mal die komplette Rule. Im Foren-Editor kannst Du mit dem 2. Knopf von links (ein T mit tief gestelltem x) für den markierten Text alle Auszeichnungen entfernen. Falls der Code nach dem Posten schief ist, kannst Du das Posting bearbeiten, bis der Code korrekt angezeigt wird.

[Sefina]

Hier nocheinmal in schön ....

rule "Stopen Manuel"
when
    Item M076R2 changed to OFF
then
    //AUF - Aus
    if ( M231R4.state == ON  && Rollo01Fahrtrichtung.state == ON) {
        Rollo01Fahrt.cancel
        Rollo01Fahrt = null
        sendCommand(M231R4, OFF)
        DauerRollo01 = now.millis - StarttimeRollo01
        Rollo0103.sendCommand(DauerRollo01*100/Rollo01Auf)
        Rollo0102.sendCommand((Rollo0101.state as Number) - (Rollo0103.state as Number))
        }else
            //ZU - Aus
            if ( M231R4.state == ON  && Rollo01Fahrtrichtung.state == OFF) {
                Rollo01Fahrt.cancel
                Rollo01Fahrt = null
                sendCommand(M231R4, OFF)
                DauerRollo01 = now.millis - StarttimeRollo01
                Rollo0103.sendCommand(DauerRollo01*100/Rollo01Zu)
                Rollo0102.sendCommand((Rollo0101.state as Number) + (Rollo0103.state as Number))
                }    
end

M076R2 ist das Netzrelai des Rolladen
M231R4 ist ein Virtueles Relai was sagt ob es Manuel gefahren worden ist oder Manuel

Nun Bezieht sich die Rechnung sogar auf ein anderen Number Item aber es geht immer noch nicht.

das Item Rollo0103 zeigt den Richtigen %ualen Fahrtweg an aber
die Endposition ( + / - ) wird nicht Richtig berechnet.

MfG

[udo1toni]

Der Code ist unvollständig. Wo wird Rollo01Fahrt definiert? Wo wird StarttimeRollo01 definiert? Wo wird DauerRollo01 definiert? Wo werden Rollo01Auf und Rollo01Zu definiert?

Grundsätzlich sollte an dieser Stelle auch weniger mehr sein. Du hast einen Rollladen, das bedeutet, Du brauchst exakt ein Item für die Darstellung dieses Rollladens, nennen wir dieses Item mal Rollo01. Dieses Item hat numerisch einen Status von 0 bis 100 (offen bis zu). Weiterhin hast Du eine Verfahrzeit für runter und eine Verfahrzeit für hoch. Die Position nach dem Verfahren ergibt sich aus

Rollo01_alte_Position + wenn(Fahrtrichtung == hoch) -1*Fahrzeit/Verfahrzeit_hoch*100 ansonsten Fahrzeit/Verfahrzeit_runter*100.

Da der Rollladen bei Dir über eine Relaiskarte gesteuert wird, wird es dort zwei Relais geben, das eine für die eine Richtung und das andere für die andere Richtung oder alternativ das eine Zum Fahren und Stoppen und das andere für die Fahrtrichtung. Es wäre natürlich sinnvoll, diese Relais so zu benennen, dass eine Zuordnung möglich ist. Also entweder beide nach der Relaiskarte M...R. oder beide mit der Funktion, also Rollo01_fahren und Rollo01_richtung oder ähnlich.

Ich gehe davon aus, dass Rollo01Fahrt ein Timer ist, der an anderer Stelle gestartet wird. Weiterhin wird StarttimerRollo01 vermutlich auch in einer anderen Rule gesetzt.

Die Rule sollte dann so aussehen:

//Variablen, die zwingend außerhalb der Rules definiert werden müssen, da sie Rule-übergreifend verwendet werden.
var Long StarttimeRollo01 = null  //wird beim Start des Rollos mit now.millis gesetzt
var Timer Rollo01Fahrt = null     //wird durch Rule gesetzt
// Konstanten
val Long Rollo01Auf = 18400       //18.4 Sekunden von 100% auf 0%
val Long Rollo01Zu = 17600        //17.6 Sekunden von 0% auf 100%

rule "Rollo01 Position manuell"
when
    Item M076R2 changed to OFF
then
    if(M231R4.state == ON) {
        Rollo01Fahrt.cancel
        Rollo01Fahrt = null
        M231R4.sendCommand(OFF)
        var Long DauerRollo01 = now.millis - StarttimeRollo01
        Rollo01.postUpdate((Rollo01.state as Number) + if(Rollo01Fahrtrichtung.state == ON) -100*DauerRollo01/Rollo01Auf else 100*DauerRollo01/Rollo01Zu)
    }
end

Allerdings bleibt noch die Frage offen, warum Du die Position nur beim manuellen Verfahren setzt.

Du musst Dir auch darüber im Klaren sein, dass openHAB kein Echtzeitsystem ist. Es gibt keine garantierten Antwortzeiten, Abläufe sind höchst variabel, das heißt, gemessene Zeiten können stark voneinander abweichen, weil z.B. eine Rule verspätet ausgelöst wird, oder deren Ablauf durch andere Prozesse gestört/verzögert wird. Eine berechnete Position wird also niemals genau sein. Am besten rechnet man deshalb mit etwas zu kurzen Laufzeiten und sorgt nach der Berechnung für die Einhaltung des Wertebereichs.
Weiterhin ist es normal, dass der Laden schon bei z.B. 90% aufsetzt, die restlichen 10% sind dann Laufzeit, bis alle Zwischenräume geschlossen sind. Dadurch stimmt dann natürlich die Fenstermitte nicht mit der Rollladenposition 50% überein.

[Sefina]

Hier der gesammte Code

import org.openhab.core.library.types.*
import org.eclipse.smarthome.core.items
import org.openhab.core.persistence.*
import org.openhab.model.script.actions.*
import org.openhab.model.script.actions.Timer

// Variablen
var Timer Rollotest
var long StarttimeRollo01
var long DauerRollo01
var long Rollo01Auf = 34100
var long Rollo01Zu = 32000
var Timer Rollo01Fahrt
var Timer Rollo01Nachlauf
var Test = 0


rule "Fahren Manuel" 
when 
    Item M076R2 changed to ON
then 
    //AUF
    if ( M231R4.state == ON && M076R1.state == ON  && Rollo0102.state > 0) {
            StarttimeRollo01 = now.millis
            sendCommand(Rollo01Fahrtrichtung, ON)
            Rollo01Fahrt = createTimer(now.plusMillis(34100)) [| 
                Rollo01Fahrt.cancel
                  Rollo01Fahrt = null
                  sendCommand(M231R4, OFF)
                  sendCommand(Rollo0102, 0)
                Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                    sendCommand(M076R2, OFF)
                    Rollo01Nachlauf.cancel
                      Rollo01Nachlauf = null
                ]
            ]
    //ZU
    }else if ( M231R4.state == ON && M076R1.state == OFF  && Rollo0102.state < 100 ) {
            StarttimeRollo01 = now.millis
            sendCommand(Rollo01Fahrtrichtung, OFF)
            Rollo01Fahrt = createTimer(now.plusMillis(32000)) [| 
                Rollo01Fahrt.cancel
                  Rollo01Fahrt = null
                  sendCommand(M231R4, OFF)
                  sendCommand(Rollo0102, 100)
                Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                    sendCommand(M076R2, OFF)
                    Rollo01Nachlauf.cancel
                      Rollo01Nachlauf = null
                ]
            ]
    //Keine Fahrt
    }else if ( M231R4.state == ON) {
            sendCommand(M076R2, OFF)
            sendCommand(M231R4, OFF)
    }    
end

rule "Stopen Manuel" 
when 
    Item M076R2 changed to OFF
then 
    //AUF - Aus
    if ( M231R4.state == ON  && Rollo01Fahrtrichtung.state == ON) {
            Rollo01Fahrt.cancel
            Rollo01Fahrt = null
            sendCommand(M231R4, OFF)
            DauerRollo01 = now.millis - StarttimeRollo01
            Rollo0103.sendCommand(DauerRollo01*100/Rollo01Auf)
            Rollo0102.sendCommand((Rollo0101.state as Number) - (Rollo0103.state as Number))
        }else if ( M231R4.state == ON  && Rollo01Fahrtrichtung.state == OFF) {
            Rollo01Fahrt.cancel
            Rollo01Fahrt = null
            sendCommand(M231R4, OFF)
            DauerRollo01 = now.millis - StarttimeRollo01
            Rollo0103.sendCommand(DauerRollo01*100/Rollo01Zu)
            Rollo0102.sendCommand((Rollo0101.state as Number) + (Rollo0103.state as Number))
        }    
end

rule "Stopen Manuel" 
when 
    Item Rollo0102 changed
then 
    //AUF - Aus
    if ( Rollo0102.state != Rollo0101.state) {
            sendCommand(Rollo0101, (Rollo0102.state as Number))
        }    
end

Weil ich bei dem Automatischen Fahren über die Visu noch nicht angekommen bin.
Deswegen ist der erste Schritt der Handbetrieb.

Die Rul muss auch erkennen wann wird über die Visu gefahren und wann Automatisch.
Desweiteren muss es auch Möglich sein den Automatikbetrieb zu blockieren aber der Handbetrieb muss funktionieren.

Mein Rollo hat keine Lamelen mit Luft dazwischen daher konnte ich es per Zeit und Sichtprüfung feststellen wieviel % es zu ist und welcher Wert Stimmt.

Auch ist es zwar net von dir mit eine 1 Zeilenrule zu schreiben aber bevor ich etwas zusammenfasse muss es erstmal in groß gehen.

Je mehr Items ich jetzt nutze, je mehr Items kann ich mir Anzeigen lassen und desto besser kann ich Zeitnah debugen.

Daher konnte ich auch Feststellen das die Berechnung von dem Item Rollo0103 stimmt weil dort wird der gefahrene % Wert angegeben.

Nu der Gesamtwert der mit Rollo0102.sendCommand((Rollo0101.state as Number) + (Rollo0103.state as Number))
berechnet wird stimmt vorn und hinten nicht.

Leider weiß ich nicht was dieses Rollo01.postUpdate macht.

Wie gesagt ich will erstmal den Handbetrieb hinbekommen

MfG

[udo1toni]

Du hast zwei Rules mit identischem Namen. Jede Rule muss systemweit einen eindeutigen Namen haben (also eindeutig nicht nur innerhalb des Rulefiles, sondern eindeutig in allen Rulefiles.)
Nutzt Du openHAB1 oder openHAB2? Falls letzteres, sind alle angegebenen Imports unnötig (openHAB2 importiert automatisch die grundlegenden Sachen); weiterhin sind *-Imports nicht mehr erlaubt.

Die doppelte Codedefinition ist kontraproduktiv. Jede zusätzliche Codezeile kann Fehler enthalten, deshalb ist es besser, den Code so zu formulieren, dass möglichst wenig Code gedoppelt ist (siehe Postung #6)

Grundsätzlich rate ich von der Action sendCommand(Item,Value) oder auch postUpdate(Item,Value) ab. Benutze lieber Item.sendCommand(Value) bzw. Item.postUpdate(Value). Das hab ich ja schon im ersten Posting erklärt, und das betrifft natürlich alle Stellen im Code.

Item.sendCommand(Value) -> sende den Wert Value an die verknüpften Bindings. Standard ist, dass openHAB anschließend automatisch den Status updated.
Item.postUpdate(Value) -> ändere ausschließich den Status des Items, sende diesen nicht an ein verknüpftes Binding.

Die Idee, für alle Zwischenberechnungen zig Items zu nutzen, ist auch eine schlechte Idee, weil openHAB Zeit braucht, den Status zu schreiben. Wenn Du dann unmittelbar den Status verwendest, liest Du eventuell noch einen alten Status. Du müsstest also zusätzlich jeweils einige 100msec Pause einlegen, um einigermaßen (aber nicht absolut!) sicher zu sein, dass Du auch wirklich den korrekten Wert verwendest.
Wenn Du über die Abläufe in der Rule informiert sein willst, kannst Du natürlich gerne Items verwenden, aber bitte eher zur Anzeige, aber eher nicht als Berechnungsgrundlage. Mit Variablen tritt dieses Timing-Problem nicht auf.
Da die Abläufe eigentlich nur zum debuggen interessant sind, ist es wesentlich sinnvoller, solche Werte per logInfo() in die Logdatei zu schreiben:
Nehmen wir an, wir haben ein Item:

Number Itemname

dessen aktueller Wert 4711 ist. Die Codezeile

logInfo("meine Rule","Wert des Items {} ist {}",item.name,item.state)

Führt dann zu einer Logzeile:

Datum/Uhrzeit/msec [...logger.meine Rule]: Wert des Items Itemname ist 4711

in der Datei openhab.log

Wenn ein Timer abläuft, wird der Code im Rumpf ausgeführt. Es ist zu diesem Zeitpunkt (der Timer ist bereits abgelaufen) vollkommen sinnlos, diesen Timer noch zu canceln. Setzen auf null kann man machen, ist aber nur dann sinnvoll, wenn Du irgendwo explizit auf null testest, ansonsten ist das nur Codemüll.

Und wenn Du schon die Laufzeit in einer Variablen speicherst (val für eine Konstante wäre besser!), solltest Du diese auch konsequent nutzen (erste Rule - Timer)

[Sefina]

Ok ....

Danke für die Erklärung ich hoffe ich habe es verstanden.

- Also Variablen den Items vorziehen

dazu eine Fragen, möchte ich ein Switch Item als Variable nutzen hat es ja den Status ON oder OFF, was für ein Variablen Typ nehme ich den da ? String ?
Also : var String Name , und dann per Variablen Änderung ein ON oder OFF schreiben ?

Ein Timer nur per Timer.cancel abbrechen.

Rulenamen wie Item-Namen nur einmalig vergeben.

Meinst du mit Code doppeln das die Schreibweise Fehler enthalten kann oder das Openhab Fehler macht ?

var val Name sollen für konstanten genutzt werden also z.b. Laufzeiten die sich nicht ändern.

Aber für Timer trotzdem var timer Name ?

Momentan versuche ich aus lauter Anleitungen die man nur halb versteht was zu basteln und daraus zu lernen.


MfG

[Sefina]

Nun Habe ich die Rules umgeschrieben komme aber auf ein neues Problem

// Variablen
var long StartZeitRollo01
var long DauerZeitRollo01
val long Rollo01AufZeit = 34100
val long Rollo01ZuZeit = 32000
var Timer Rollo01Fahrt
var Timer Rollo01Nachlauf
var long Rollo01JetztProzent
var long Rollo01AltProzent
var boolean Rollo01Fahrtrichtungtest  //true = hoch false = runter


rule "Fahren Manuel" 
when 
    Item M076R2 changed to ON
then 
    //AUF
    if ( M231R4.state == ON && M076R1.state == ON  && Rollo01JetztProzent > 0) {
            StartZeitRollo01 = now.millis
            Rollo01Fahrtrichtungtest = true
            Rollo01Fahrt = createTimer(now.plusMillis(Rollo01AltProzent * 100 / Rollo01AufZeit)) [| 
                M231R4.sendCommand(OFF)
                  Rollo01JetztProzent = 0
                Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                    M076R2.sendCommand(OFF)
                ]
            ]
    //ZU
    }else if ( M231R4.state == ON && M076R1.state == OFF  && Rollo01JetztProzent < 100 ) {
            StartZeitRollo01 = now.millis
            Rollo01Fahrtrichtungtest = false
            Rollo01Fahrt = createTimer(now.plusMillis(100 - Rollo01AltProzent * 100 / Rollo01ZuZeit)) [| 
                M231R4.sendCommand(OFF)
                  Rollo01JetztProzent = 100
                Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                    M076R2.sendCommand(OFF)
                ]
            ]
    //Keine Fahrt
    }else if ( M231R4.state == ON) {
            M076R2.sendCommand(OFF)
            M231R4.sendCommand(OFF)
    }    
end

rule "Stopen Manuel" 
when 
    Item M076R2 changed to OFF
then 
    //AUF - Aus
    if ( M231R4.state == ON  && Rollo01Fahrtrichtungtest == true) {
        Rollo01Fahrt.cancel
        M231R4.sendCommand(OFF)
        DauerZeitRollo01 = now.millis - StartZeitRollo01
        Rollo0103.sendCommand(DauerZeitRollo01*100/Rollo01AufZeit)
        Rollo01JetztProzent = Rollo01AltProzent - DauerZeitRollo01 * 100 / Rollo01AufZeit
        Rollo0101.sendCommand(Rollo01JetztProzent) 
        }else if ( M231R4.state == ON  && Rollo01Fahrtrichtungtest == false) {
            Rollo01Fahrt.cancel
            M231R4.sendCommand(OFF)
            DauerZeitRollo01 = now.millis - StartZeitRollo01
            Rollo0103.sendCommand(DauerZeitRollo01*100/Rollo01AufZeit)
            Rollo01JetztProzent = Rollo01AltProzent + DauerZeitRollo01 * 100 / Rollo01AufZeit
            Rollo0101.sendCommand(Rollo01JetztProzent)
        }    
end

rule "Visu update Manuel + Ausgleich" 
when 
    Item Rollo0101 changed
then 
    if ( Rollo01JetztProzent < 0 ) {
        Rollo01JetztProzent = 0
        Rollo01AltProzent = 0
        Rollo0101.sendCommand(0)
    }else if ( Rollo01JetztProzent > 100 ) {
            Rollo01JetztProzent = 100
            Rollo01AltProzent = 100
            Rollo0101.sendCommand(100)
        }else if ( Rollo01JetztProzent != Rollo01AltProzent) {
                Rollo01AltProzent = Rollo01JetztProzent
                Rollo0101.sendCommand(Rollo01JetztProzent)
            }
end

Leide habe ich bei den 2 Timern die ich auch angepasst habe (beim hoch und runterfahren) das Problem das diese Falsch sind.

Ich darf keine long Variablen in einen Timer nutzen (dieser möchte int)
diefieniere ich diese Variable um kann ich nicht von long zu int wandeln.

Wie macht man das, da ist das Internet sehr sparsam mit Infos.

MfG

[udo1toni]

Du meinst diesen Term?

Rollo01AltProzent * 100 / Rollo01AufZeit

Es gibt verschiedene Möglichkeiten, Typkonvertierungen zu erzwingen. Probier mal

new Integer(Rollo01AltProzent * 100 / Rollo01AufZeit)

Um das Suchen etwas weniger frustrierend zu gestalten : Grundsätzlich verwendet openHAB für die Rule Engine eine DSL (DomainSpecificLanguage) auf Basis von XBase, welches wiederum auf XTend aufsetzt. Da das Ganze unter Java programmiert ist, liegt es nahe, dass viele Sprachdetails ähnlich wie bei Java sind.
Viele Arbeitsweisen kannst Du also von dort ableiten, bzw. gezielt nach diesen Begriffen suchen.

Wenn Du Dir das englische Forum anschaust, wirst Du feststellen, dass dort tausende Postings mit Code zu finden sind. Aber die wenigsten werden ihre Codeschnipsel auch noch verschlagworten (ist auch etwas schwierig, man weiß ja als Suchender auch nicht unbedingt, nach welchen Begriffen man suchen muss), es ist also eher so, dass man blind suchen muss, dann aber in solchen Beispielen viele kleine Details findet, die man dann nach und nach im eigenen Code einbauen kann.

[Sefina]

Habe es geändert

Rollo01Fahrt = createTimer(now.plusMillis(new Integer (Rollo01AltProzent * 100 / Rollo01AufZeit))) [|
                M231R4.sendCommand(OFF)
                  Rollo01JetztProzent = 0

Leider ohne erfolg, immer noch "cannot convert from long to int"

Das geht auch nicht

Rollo01Fahrt = createTimer(now.plusMillis(Integer.valueOf (Rollo01AltProzent * 100 / Rollo01AufZeit))) [| 
                M231R4.sendCommand(OFF)

"cannot confert from long to string"

MfG

[udo1toni]

Kann es sein, dass die Formel schon nicht stimmt? Du willst ja einen Bruchteil der jeweiligen Laufzeit. Also müsste es eigentlich

Rollo01AltProzent / 100 * Rollo01AufZeit

heißen.
Die Berechnung des Integers könnte auch so klappen:

(new Float(Rollo01AltProzent / 100 * Rollo01AufZeit)).intValue

Float habe ich jetzt genommen, weil vermutlich nicht unbedingt ein ganzzahliges Ergebnis raus kommt. Beim Umwandeln nach int werden dann die Nachkommastellen abgeschnitten, aber die Umwandlung von Float nach int geht immer - vorausgesetzt, die Zahl passt in den Wertebereich von int. int ist im java-Standard 32 Bit breit, so dass dies keine Einschränkung ist (2.147.483.647 bis - 2.147.483.648)
Falls auch dies fehlschlägt, müssten wir doch mal mit logInfo die konkreten Werte ausgeben, die da ausgerechnet werden:

logInfo("meinlog","Rollo01AltProzent: {} Rollo01AufZeit: {} Laufzeit: {}",Rollo01AltProzent,Rollo01AufZeit,Rollo01AltProzent*Rollo01AufZeit/100)

wobei hier natürlich keine Nachkommastellen abgeschnitten werden, und da das Ergebnis vom Typ Float sein wird, können da viele Nachkommastellen auftauchen.