HS/FS Frage zur Logikentwicklung

[derPaul]

Moin,
ich hab 2 Fragen an die Logikentwickler hier.

Ich selber hab mir jetzt schon 1-2 kleinere Bausteine geschrieben und das läuft auch alles super.
Jetzt möchte ich aber gerade etwas probieren und weiß nicht so recht ob ich das richtig gemacht habe bzw wie es besser geht.

Ich hab dazu ein paar vorhanden Bausteine von hier und auch auf github studiert.

Gegeben ein Pythoncode Block in dem ich die Daten verarbeite.
Angenommen mein LBS hat 4 Ausgänge und ich möchte in einer Funktion alle 4 Ausgänge mit Daten füttern.

Wie mache ich das richtig?
Auf github hab ich folgendes dazu gefunden (wie self.logik gefüllt wird etc. hatte ich gesehen)

def sendToOutput(self, out, value):
    self.AN[out] = value
    out -= 1 ## Intern starten die Ausgänge bei 0 und nicht bei 1
    if self.logik.SendIntervall == 0 or time.time() >= self.logik.Ausgang[out][0]:
        for iko in self.logik.Ausgang[out][1]:
            self.logik.MC.TagList.setWert(FLAG_EIB_LOGIK, iko, value)
        if value:
            for cmd in self.logik.Ausgang[out][2]:
                cmd.execBefehl()
        for con in self.logik.Ausgang[out][3]:
            self.logik.MC.LogikList.ConnectList.append(con + [ value ])
        if self.logik.SendIntervall > 0:
            self.logik.Ausgang[out][0] = time.time() + self.logik.SendIntervall
    self.logik.OutWert[out] = value

Ausserdem noch eine Frage zum Auslösen der Formel.

Angenomme ich hab am Eingang ein Status und dieser wird am Ausgang ausgegeben.

Nun würde er im Prinzip ja durch die Änderung wieder in den LBS rutschen.

Ich prüfe derzeit mittels

EC[1] and (EN[1] != AN[1])

Ist das so die korrekte Herangehensweise?

Vielen Dank
Gruß
Paul

[NilsS]

Hi Paul,

das ist immer abhängig davon wo du dich befindest.

Also, wenn du nur eine einfache Funktion aufrufst in der etwas gemacht wird, benötigst du die oben beschriebene Funktion nicht, dort reicht es einfach AN und AC an die Funktion zu übergeben und
AN[1] = "mein Wert Ausgang 1"
AC[1] = 1 # ja ausgang hat sich geändert
AN[2] = "mein Wert Ausgang 2"
AC[2] = 1 # ja ausgang hat sich geändert

das funktioniert weil AN dann in der Funktion keine lokale Variable ist, sonder die List ein Objekt aus der Logikfunktion calc ist.

Wenn du jetzt aber einen Baustein von der eigentlich Logikschleife trennst durch einen Thread, oder aber andere Umstände (z.B. verzögerung) für einen nicht gleichen Ablauf nutzt dann kannst du oben genannte Funktion (die gibts auch noch ein bisschen weiterentwickelt damit sie auch SBC kann) ,
Die kannst du so oft du möchtest aufrufen entweder indem du vorher pItem (die aktuelle Logik) als self.logik definierst.
Oder du änderst die Funktion das pItem mit übergeben wird und tauscht alle self.Logik gegen pItem aus (das self.AN schmeißt du raus, das gibts nicht un bringt denke ich Chaos.

    def send_to_output(self,pItem,out,value):
        import pht
        out -= 1 ## Intern starten die Ausgänge bei 0 und nicht bei
        if pItem.LogikItem.Ausgang[out][1] == 1:
            value = bool(value)

        if pItem.LogikItem.Ausgang[out][2] == 2 and pItem.OutWert[out] == value: ##sbc
            return False
        ## Sendeintervall wird beachtet
        if pItem.SendIntervall == 0 or pht.times() >= pItem.Ausgang[out][0]:
            ## Wert an allen iKOs an den Ausgängen setzen
            for iko in pItem.Ausgang[out][1]:
                pItem.MC.TagList.setWert(FLAG_EIB_LOGIK, iko, value)
            
            if value:
                for cmd in pItem.Ausgang[out][2]:
                    cmd.execBefehl()
            
            ## Direkte Verbindungen und Connectoren
            for con in pItem.Ausgang[out][3]:
                pItem.MC.LogikList.ConnectList.append(con + [ value ])
            ## Wenn Sendeintervall gesetzt, nächste mögliche Ausführungszeit setzen
            if pItem.SendIntervall > 0:
                pItem.Ausgang[out][0] = pht.times() + pItem.SendIntervall
            ## Ausgangswert auch in der Logik setzen
            pItem.OutWert[out] = value
        
        return True

das ist die Funktion aus dem aktuellen hs_insight
dort wird zusätzlich noch True/False zurückgegeben ob auch wirklich gesendet wurde

d (EN[1] != AN[1])

löst das SBC

Wenn du fragen hast oder den ein oder anderen Baustein als .hsb File benötigst sag einfach Bescheid

[derPaul]

Moin Nils,
ah perfekt vielen Dank. In meiner Vorstellung war es so wie du beschreibst nur habe ich die Funktion nicht so recht verstanden.
Das hat mich irritiert.

Dann werd ich da mal weiter schauen.

Danke. Ich komm dann ggf. bei weiteren Fragen auf dein Angebot zurück.
Macht jedenfalls Spaß die Sachen die ich bislang ausgelagert hatte nun via LBS in den HS umzuziehen :-)

Gruß
Paul

[derPaul]

NilsS : Ich versteh das richtig, sofern ich nach dem senden an de Ausgang noch was anderes im Code machen will muss ich die Funktion nutzen korrekt?

[NilsS]

Die Logik funktioniert folgendermaßen
#5012|abbruch bei bed. (0/1)|bedingung|formel|zeit|pin-ausgang|pin-offset|pin-speicher|pin-neg.ausgang

def calc:.....
    EN = [0] + pItem.Inwert[:]
    EA = ....
    EC = [0] + anzahl Eingänge * [0]
    AN = [0] + pItem.Outwert[:]
     ... usw
    for x in self.formel:
       if eval(x[0]) > 0: ## die bedingung 
           wert = eval(x[1]) ## die formel
           AN[x[4]] = wert ## x[4] ist PIN Ausgang
..........

hier kommt jetzt so oder so die oben genannte Funktion die die Ausgangswerte AN[x] in
pItem.MC.TagList.setWert(FLAG_EIB_LOGIK, iko, value) schreibt
wenn du jetzt in deiner Formel x[1] jetzt eval(compile(....deine base64codierter Source )) hast
base64codierter Source ist:
AN[3]= "blah"

dann wird genau wie in der for schleife das AN[..] mit einem Wert beschrieben (lokale Variablen der Funktion calc und deines evals sind gleich)
Die Funktion die "wirklich" auf den Ausgang schreibt sieht nachher NUR das AN

Wenn du jetzt in deinem eval aber etwas machst das sich vom Zeitablauf (z.B. durch Threading) nicht mehr linear zur calc Funktion verhält, dann kann (auch wenn du danach noch AN[x] änderst das auch beim nächsten durchlauf der calc Funktion nicht mehr berücksichtigt werden. Da AN ja nur lokal ist und beim Aufruf immer überschrieben wird.

Wenn du die Funktion send_to_output nutzt bist du immer auf der sicheren Seite, aber evtl auch ineffektiv.

Beispiel
... eval code

class mycode:
   def somefunction(self,pItem,EN,AN,AC):
       if EN[1] == 1:
            AN[1] = "Wert 1"
            self.send_to_output(pItem,1,"Wert 2")
            return "Wert 3"

     def send_to_output(self,pItem,out,value):
            .......

SN[1]=myclass()

in der 5012er Zeile später rufst du die Funktion dann auf
5012|0|"EC[1]"|"SN[1].somefunction(pItem,EN,AN,AC)"|""|1|0|0|0

was passiert jetzt.
du setzt den Ausgang in der Logik auf "Wert 1" (passiert erstmal noch nix)
du schreibst "Wert 2" JETZT direkt auf alles was an Ausgang 1 hängt
du beendest die Funktion mit "Wert 3" die auf pin Ausgang 1 schreibt
DIe Logik erkennt PIN AUsgang gesetzt und überschreibt dein AN[1] = Wert 1 mit Wert 3 und sendet jetzt Wert 3

[derPaul]

Muss an dieser Stelle mal nen dickes Dankeschön an Nils los werden!!