Gira X1 Logik fur Betriebumschaltung

[wv02447]

Der Logikbaustein Formelberechnung funktioniert einwandfrei. Leider verstehe ich die Syntax nicht, aber das Wichtigste ist, dass sie genau das tut, was ich brauche, nämlich ein 1-Byte-Objekt in 1-Bit-Objekte aufzuteilen. Für die Betriebsart brauche ich nur die ersten 4 Bits und der Rest ist mir nicht wichtig. Ich habe jetzt für jeden Regler eine Logik erstellt, die diesen Wert abhängig von den 1-Bit-Objekten über einen Wertegenerator an das Betriebsmodusobjekt des X1-Regler zurückgibt.
Ich bin natürlich offen für Verbesserungen oder Kommentare und möchte mich nochmals ganz herzlich für Ihre Hilfe bedanken.

[knxPaul]

Vielen Dank für die Blumen 🌼💐🌷
Die Syntax des Logikbausteinswird in der Hilfe > "Weitere Informationen" kurz erklärt mit dem Verweis auf das verwendete .NET 4.0 API von Microsoft.
Mit diesem Wissen sollte möglich sein, die Umrechnung durch die Wertgeneratoren in die Formelberechnung zu integrieren.

[chribo]

Hallo zusammen,

ich dachte schon mit dem Formelgenerator habe ich die Lösung für mein Problem gefunden und kann ein 2 Byte Status in die einzelnen Informationen aufteilen. Blöderweise kann mehr als ein Bit = 1 sein da es sich um den Status eines Rollladenaktors handelt. Ich möchte wissen wann der Behang fährt, Dabei gibt er immer "Behang in Bewegung" & "Fahrt Auf" oder "Fahrt Ab" aus. Dazu kommt noch das im ersten Byte verschiedene Betriebsmodi übertragen werden.

Ich würde also eine Formel benötigen die mir wirklich nur das Bit 9 ausließt. In C bin ich leider nicht so bewandert. Kann mir hier jemand weiterhelfen oder ist der Formelbaustein dann komplett ungeeignet?

Grüße
Chris

[knxPaul]

Der LBS Formelberechnung ist auch dafür geeignet: Wenn die Bits von 0 bis 15 gezählt werden: Bit 9 = 2^9 = 512
dann ist die Abfrage vom Eingang X auf Bit 9

({X:I} & 512) != 0

Das Ergebnis meiner Formel ist TRUE oder FALSE je nach dem Wert von Bit 9

[chribo]

Hallo Paul,

die Idee hatte ich auch erst klappt aber nicht, da alle andern Bits beliebig gesetzt oder nicht gesetzt sein können. Ist also mal Angenommen Bit 5 und Bit 12 gesetzt wäre der Integer Wert 2^5 + 2^12 und somit 2064. Der Wert ist also größer gleich 512 ohne dass der Rollladen fährt.

Ich denke dein Ansatz der ersten Seite ist hier vielversprechender. Wie gesagt meine C Kenntnisse sind sehr rustikal aber so wie ich das interpretiere fragst du hier jedes Bit einzeln ab. Ich versuche gerade mir das für die anderen Bits zusammenzubasteln ist aber mehr Try n Error als das ich wirklich verstehe was ich da tue.

[/LIST]

{X:I} % 2
({X}-{X}%2)%4/2
({X}-{X}%2-2*({X}-{X}%2)%4/2)%8/4
({X}-{X}%2-2*({X}-{X}%2)%4/2-4*({X}-{X}%2-2*({X}-{X}%2)%4/2)%8/4)%16/8
({X}-{X}%2-2*({X}-{X}%2)%4/2-4*({X}-{X}%2-2*({X}-{X}%2)%4/2)%8/4-8*({X}-{X}%2-2*({X}-{X}%2)%4/2-4*({X}-{X}%2-2*({X}-{X}%2)%4/2)%8/4)%16/8)%32/16

Die erste Zeilen verstehe ich noch
{X:I} %2 --> Definiere X als Integer, Teile Wert durch 2 und gebe den Rest aus. --> Ergo Wert ungerade Bit 1 =1
({X]-{X}%2)%4/2 --> (Ziehe wenn die Zahl ungerade ist 1 ab) Teile durch 4 um alles kleiner Bit 3 zu filtern und teile durch 2 um den Wert 1 als True zu bekommen

dann hört es bei mir leider so langsam auf

[knxPaul]

klappt aber nicht, da alle andern Bits beliebig gesetzt oder nicht gesetzt sein können

hast Du das ausprobiert?
Ich hatte das so gedacht:
x & 512 ist eine bitweise UND Verknüpfung des Eingangswertes mit '0010 0000 0000'. Im Ergebnis bleibt nur das gewünschte Bit 9, alle anderen Bits sind zwangsweise 0. Daher liefert der Vergleich vom Ergebnis mit 0 den Wert vom Bit 9.

Die komplizierten Formeln machen das gleiche, nur enorm aufwändiger. Diese Methode funktioniert nur iterativ vernünftig.

[chribo]

knxPaul ok ich nehme alles zurück. Es funktioniert!
Vielen Dank für die Hilfe. Über die Formel hätte es nicht mehr geklappt da sie zu lang war und daher einen Fehler erzeugt hat.

Hier also die Formeln um 2 Byte komplett auszuwerten:

{X:I} % 2
({X} & 2) != 0
({X} & 4) != 0
({X} & 8) != 0
({X} & 16) != 0
({X} & 32) != 0
({X} & 64) != 0
({X} & 128) != 0
({X} & 256) != 0
({X} & 512) != 0
({X} & 1024) != 0
({X} & 2048) != 0
({X} & 4096) != 0
({X} & 8192) != 0
({X} & 16384) != 0
({X} & 32768) != 0
​