SPS AWL Fehler?

Zuviel Werbung?
-> Hier kostenlos registrieren
Code:
OE 1.0
UE 1.1
UE 1.2
=A 1.1  
--> genau gleich wie erstes Beispiel, das der Operand des ersten Verknüpfungs-Ausdruckes nicht berücksichtigt wird
Doch, der Operand (also E 1.0) wird berücksichtigt und auch ggfs das N des Operators (wenn dort UN bzw. ON bzw. XN steht). Nicht berücksichtigt wird das U bzw. O bzw. X des Operators.

Code:
     Ü   E 1.0
     U   E 1.1
     O   E 1.2
     O   E 1.3

entspricht

           +-----+
E 1.0 -----|  &  |
           |     |       +-----+
E 1.1 -----|     |-------| >=1 |
           +-----+       |     |
                         |     |       +-----+
E 1.2 -------------------|     |-------| >=1 |
                         +-----+       |     |
                                       |     |
E 1.3 ---------------------------------|     |-----
                                       +-----+

entspricht

           +-----+
E 1.0 -----|  &  |
           |     |       +-----+
E 1.1 -----|     |-------| >=1 |
           +-----+       |     |
                         |     |
E 1.2 -------------------|     |
                         |     |
                         |     |
E 1.3 -------------------|     |-----
                         +-----+

entspricht


|    E 1.0      E 1.1        
|-----[ ]--------[ ]----+------------    
|                       |
|                       |
|    E 1.2              |
|-----[ ]---------------+
|                       |
|                       |
|    E 1.3              |
|-----[ ]---------------+
|
Ist das verständlich?
 
Zuletzt bearbeitet:
Achso, ja meinte den Operator (Wie komme ich auf Operand :/). Aber dennoch sind Beispiel 1 und 2 gleich, richtig?


Ja, wenn man weiß, dass die Auswertung von oben nach unten abläuft.
Wie wäre es dann bei:
Code:
     O   E 1.0
     O   E 1.1
     U   E 1.2
     U   E 1.3
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ja, "Aber dennoch sind Beispiel 1 und 2 gleich, richtig?" sind "identisch".

Code:
O   E 1.0
O   E 1.1
U   E 1.2
U   E 1.3

entspricht

           +-----+
E 1.0 -----| >=1 |
           |     |       +-----+
E 1.1 -----|     |-------|  &  |
           +-----+       |     |
                         |     |       +-----+
E 1.2 -------------------|     |-------|  &  |
                         +-----+       |     |
                                       |     |
E 1.3 ---------------------------------|     |-----
                                       +-----+

entspricht

           +-----+
E 1.0 -----| >=1 |
           |     |       +-----+
E 1.1 -----|     |-------|  &  |
           +-----+       |     |
                         |     |
E 1.2 -------------------|     |
                         |     |
                         |     |
E 1.3 -------------------|     |-----
                         +-----+

entspricht

|    E 1.0       E 1.2       E 1.3  
|-----[ ]----+----[ ]---------[ ]---    
|            |
|            |
|    E 1.1   |
|-----[ ]----+
|
 
Ok, also kann man sich denken, dass (ohne Klammern und ohne reinen O Operator) einfach strikt von oben nach unten durchgegangen wird?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ok, dann hätte ich noch eine letzte Bitte.
Habe in unterem Bild mal ein paar grundlegende Fälle aufgeschrieben.
Könntest du prüfen ob:
1. Alle AWL mit den dazugehörgen Funktionsplänen übereinstimmen.
2. Alle Blau markierten Buschstaben kann ich (nach meinem Verständinis) durch einen beliebigen der Buchstaben U, O, X ersetzen, ist das richtig?20180520_215345.jpg
 
Habe nochmal wegen der Klammerei nachgeschlagen:
Anhang anzeigen KlammerAusdruecke.pdf

Was ich zum Thema "egal-bei-ErstVerknüpfung" gesagt hatte, hatte ich eigentlich nicht auf U(, UN(, O(, ON(, X( oder XN( bezogen, sondern auf die entsprechen Verknüpfungen mit Operanden-Angabe.
Bei diesen öffnenden Klammern würde ich vorsichtshalber und wegen der besseren Lesbarkeit schon O( schreiben, wenn ich O( meine u.s.w..

Auch bei den ErstVerknüpfungen mit Operanden würde ich U schreiben, wenn ich U meine u.s.w..
Das ist einfach besser lesbar (jedoch an dieser Stelle nicht wesentlich für die richtige Verarbeitung).

Auf das Thema war ich nur aus "historischen Gründen" gekommen, weil es bei einigen CPUs für die richtige Funktion wichtig war, bei ErstVerknüpfungen immer U bzw. UN zu schreiben - auch dann, wenn man eigentlich lieber O bzw. ON hätte schreiben wollen (X bzw. XN gab es damals noch nicht).
Habe hier leider nix zum Testen, deshalb bei öffnenden Klammern vorsichtshalber nicht U( statt O( oder umgekehrt u.s.w. schreiben!

Ansonsten bin ich mit Deinem Zettel einverstanden.
Wie bereits zuvor gesagt, werden die Klammern so gesetzt und im Endeffekt auch so verabeitet, wie man es erwartet. Nur "intern" verarbeitet die CPU die Befehle doch von oben nach unten und sorgt über den VKE-Stack dafür, dass ZwischenErgebnisse intern abgespeichert und im richtigen Moment wieder berücksichtigt werden.
 
Zuletzt bearbeitet:
Zurück
Oben