# SPS AWL Fehler?



## xxxyyyx (20 Mai 2018)

Hallo, 
die rechte AWL soll die linke Tabelle ergeben.
Meiner Meinung nach fehlt da ein U.
Sonst weiß ich ja garnicht, wie ich den Ausdruck in der Klammer mit dem darüber stehenden verknüpfen soll.


Was meint Ihr?


----------



## oliver.tonn (20 Mai 2018)

Was willst Du mit dem mördermäsigem Konstrukt für A1.0? Sobald E1.0 TRUE wird ist auch A1.0 TRUE, da reicht eine einfache Zuweisung.

Von irgendwas mit Internetzugang gesendet


----------



## Heinileini (20 Mai 2018)

```
Diese Schreibweise gibt's nicht:

U    E1.0
(ON  M1.0
O    M2.0)
=    A1.0

diese wäre richtig:
 
U    E1.0
U( 
ON   M1.0
O    M2.0
) 
=    A1.0

oder ohne Klammern:
 
ON   M1.0
O    M2.0
U    E1.0
=    A1.0

Laut Deiner Tabelle wäre am einfachsten:

U E1.0
= A1.0

dann brauchst Du weder M1.0 noch M2.0 noch E2.0 ;o)
```

Gruss, Heinileini


----------



## oliver.tonn (20 Mai 2018)

Und bei den Merkern denkst Du zu kompliziert. Es gibt eine Bedingung bei der M1.0 TRUE ist und M2.0 FALSE, bei allen anderen ist es umgekehrt. Wenn Du diese Bedingung in AWL schreibst weist Du das VKE M1.0 zu und das invertierte VKE M2.0

Von irgendwas mit Internetzugang gesendet


----------



## xxxyyyx (20 Mai 2018)

Danke für eure Verbesserungstipps.

Aufgabe ist es aber nur die Tabelle an Hand der rechten AWL auszufüllen.

Wie Heinileini bestätigt hat, hat die gedrucke AWL aber einen Fehler, richtig müsste es so heißen wie rechts daneben geschrieben.


----------



## xxxyyyx (20 Mai 2018)

Vielleicht noch eine andere Frage:

```
Laut Deiner Tabelle wäre am einfachsten:

U E1.0
= A1.0

Warum benötige ich das U vor dem E1?
Muss ich das schreiben, oder kann ich auch schreiben:
E1.0
=A1.0
```


----------



## Heinileini (20 Mai 2018)

Für eine "ErstVerknüpfung" benutzt man die gleiche Schreibweise wie für die folgenden Verknüpfungen.
Hat für den Interpreter/Compiler den Vorteil, das er nicht so viele verschiedene OP-Codes unterscheiden muss.
Es gab mal S5-CPUs, bei denen musste die ErstVerknüpfung immer U oder UN lauten, egal, ob's im Rahmen einer UND- oder ODER-Verknüpfung stand.
O bzw. ON konnte man zwar schreiben … und sich dann einen Wolf suchen, warum die CPU "falsch" gerechnet hat.
Bei heutigen CPUs kann man also bei der ErstVerknüpfung U oder O oder X schreiben, wenn das Bit nicht negiert werden soll oder UN oder ON oder XN, wenn das Bit negiert werden soll.
Ganz egal, die ErstVerknüpfung bildet nur das VKE. Erst die nächste Verknüpfung sagt, ob über UND oder ODER oder XOR verknüpft wird.

PS:
Je mehr verschiedene OP-Codes es gibt, desto lääänger werden die OP-Codes. Darum gibt es auch Befehle, die 1 oder 2 oder 3 Worte belegen. Es soll nicht mehr Speicher mit unnötig langen BefehlsCodes verschwendet werden. Du weisst doch: Wir müssen sparen, koste es, was es wolle!!! ;o)


----------



## xxxyyyx (20 Mai 2018)

Ok, aber es muss
UE 1.0 oder OE 1.0 oder XE 1.0 heißen, nur E 1.0 wäre falsch?


----------



## Heinileini (20 Mai 2018)

So ist es!
Nur E1.0 wäre nur der Operand, mit dem etwas gemacht werden soll. Da fehlt noch der Operator (U, O, X, UN, ON, XN), der sagt, was damit gemacht werden soll.
Man könnte für die ErstVerknüpfung eine spezielle Codierung ausgucken, aber tut es nicht, sondern benutzt die "üblichen" Operatoren, die aber nichts aussagen über UND oder ODER oder XOR, sondern lediglich, ob das Bit negiert wird (mit N) bzw. nicht negiert wird (ohne N).


----------



## xxxyyyx (20 Mai 2018)

Hätte noch eine kleine Frage  : Wie ist das mit der Stärke der Verknüpfungen?


```
UA 1.1
UNE 1.2
O
UNA 1.1
UE 1.2
SA 2.1

Gleich wie?:
O(
UA 1.1
UNE 1.2
)
O(
UNA 1.1
UE 1.2
)
SA 2.1

oder?
UA 1.1
U(
ONE 1.2
ONA 1.1
)
UE 1.2
SA 2.1
```


----------



## Heinileini (20 Mai 2018)

Die beiden ersten sind gleich. Die Klammern werden erst interessant, wenn Du mehr als 1 Klammer-Ebene verwendest.
X   A 1.1
X   E 1.2
SA  2.1​könnte man stattdessen schreiben, weil das Ergebnis 1 ist, wenn beide "Eingänge" der Verknüpfung unterschiedlich sind.

Bei der dritten Variante muss ich ja schon überlegen, was die macht.
(/E1.2 + /A1.1) * E1.2 * A1.1
Da kommt immer 0 heraus!!! Wenn E1.2 und A1.1 1 sind, liefert die ODER-Verknüpfung eine 0.
stellt also eine andere Verknüpfung dar … eine ziemlich nutzlose.


----------



## xxxyyyx (20 Mai 2018)

Wie wäre es hier?



```
OE 1.1
OE 1.2
U
OE 1.3
OE 1.4
```

Würde das heißen:
(E1.1 oder E1.2) und (E1.3 oder E1.4)

d.h. es würde dem hier entsprechen:

```
U(
OE 1.1
OE 1.2
)
U(
OE1.3
OE 1.4
)
```


----------



## Heinileini (20 Mai 2018)

Die Schreibweise im ersten Fall gibt es (leider) nicht.


----------



## xxxyyyx (20 Mai 2018)

Das heißt hier müssten Klammern gesetzt werden?


----------



## xxxyyyx (20 Mai 2018)

Was wäre dann:


```
OE 1.0
UE 1.1
UE 1.2
OE 1.3
```

Die ersten drei Zeilen würden ja bedeuten E1.0 und E1.1 und 1.2.
Würde das dann bedeuten:
1. Entweder müssen alle drei Eingänge 1.0, 1.1, 1.2 oder Eingang 1.3 auf high sein
2. Oder geht das auch nicht und ich müsste anstelle dessen für die in 1. beschriebene Funktion schreiben:

```
O(
OE1.0      --oder muss hier dann ein UE stehen?
UE1.1
UE1.2
)
OE1.3
```


----------



## Heinileini (20 Mai 2018)

OE 1.0
UE 1.1
UE 1.2
OE 1.3

ist identisch mit

UE 1.0  <===<<< bei der "ErstVerknüpfung" ist es heutzutage "wurscht", aber weniger verwirrend liest sich U E 1.0 
UE 1.1
UE 1.2
OE 1.3

Die Schreibweise mit Klammern ist auch OK, aber hier nicht nötig.
Das Ergebnis der UND-Verknüpfungen wird über ODER mit E 1.3 verknüpft, weil die Befehle von oben nach unten abgearbeitet werden, solange man nicht durch Klammern oder das alleinstehende O (ohne Operand) etwas anderes bewirkt.
​Ist also "Geschmackssache".
​


----------



## Heinileini (20 Mai 2018)

xxxyyyx schrieb:


> … 1. *Entweder* müssen alle drei Eingänge 1.0, 1.1, 1.2 *oder* Eingang 1.3 auf high sein …


Das habe ich ja glatt überlesen:
Entweder-Oder ist etwas anderes als Oder!!! … und beschreibt nicht das, was Du in AWL formuliert hast.
Oder, auch Inklusiv-Oder genannt:
A B | C 
0 0 | 0
0 1 | 1
1 0 | 1
1 1 | 1
Entweder-Oder, auch Exklusiv-Oder bzw. Antivalenz bzw. XOR genannt:
A B | C 
0 0 | 0
0 1 | 1
1 0 | 1
1 1 | *0

*PS:
"inklusiv": schliesst den Fall ein, dass alle Eingänge 1-Signal haben.
"exklusiv": schliesst den Fall aus, dass alle Eingänge 1-Signal haben, insofern das Ergebnis nicht 1 sondern 0 ist.

PPS:
UND-, ODER-, NAND- sowie NOR-Verknüpfungen sind auch mit mehr als zwei Eingängen "harmlos" bzw. eindeutig.
Bei XOR bzw. XNOR (Äquivalenz) finde ich, sollte man genau definieren, was man meint, wenn man mehr als zwei Eingänge über XOR bzw. XNOR verknüpfen will! Missverständnisse sind sonst vorprogrammiert!​


----------



## xxxyyyx (20 Mai 2018)

> Das habe ich ja glatt überlesen:



Und ich habe mich falsch ausgedrückt. Ich meinte das ganz normale Oder (also auch beide können 1 sein).
-----------------------------------------------

So ganz klar scheint mir das mit der Auswertelogik noch nicht zu sein.
Wie geht die SPS denn beim Auserten vor?

Habe folgendes gelesen:
- Bei gleichen Operanden erfolgt die Verrechnung von oben nach unten
Bsp:

```
UE 1.0
UE 1.1
UE 1.2
```
Würde bedeuten, dass zunächst E1.0 und E1.1 miteinander verrechnet werden. Das Ergebnis wird dann mit E1.2 verrechnet.

- Wenn keine Klammern gesetzt sind, haben U Vorrang vor O
Bsp.:

```
OE 1.0
UE 1.1
UE 1.2
```
Würde bedeuten, dass erst E1.1 und E1.2 verrechnet werden. Das Ergebnis daraus wird dann mit E1.0 verrechnet.

- Du meintest wenn ein O alleinesteht, dann wird das am Ende ausgeführt
Bsp:

```
UE 1.0
UE 1.1
O
UE 1.2
UE 1.3
```
Würde bedeuten, dass erst E1.0 und E1.1 verrechent werden. Dann werden E1.2 und E1.3 miteinadner verrechnet. Dann werden die Ergebnisse der vorherigen 2 Verrechnungen miteinander verrechnet.

- Das was in Klammern steht wird zuerst berechnet. D.h. je weiter Verschachtelt ein Ausdruck seht, deso früher wird er verrechnet
Bsp:

```
U(
OE 1.0
OE 1.1
O(
UE 1.4
UE 1.5
)
)
U(
OE 1.2
OE 1.3
)
```
Würde bedeuten:
1. E 1.4 wird mit E 1.5 verrechnet. 
2. E 1.0 wird mit E 1.1 verrechnet.
3. Das Ergebnis von 2 wird mit dem Ergebnis von 1 verrechnet.
4. E1.2 wird mit E 1.3 verrechnet.
5. Das Ergebnis von 3 wird mit dem Ergebnis von 4 verrechnet.


Jetzt hoffe ich, dass meine Überlegungen so passen 

P.S. Danke übrigens für deine bisherige Unterstützung


----------



## Heinileini (20 Mai 2018)

Es wird immer von oben nach unten berechnet aBär, wenn "O-mit-ohne-Operand" bzw. Klammern "dazwischenfunken", dann wird das VKE (VerknüpfungsErgebnis) auf einem Stack (LiFo) geparkt und mit einer "getürkten" ErstVerknüpfung weitergerechnet bzw. es wird ein im Stack geparktes VKE mit dem "eigentlichen" VKE verknüpft.
Klingt kompliziert und muss man nicht wirklich verstehen - Hauptsache, die CPU macht es richtig ;o)
Richtig gut zu lesen ist ein AWL-Programm für meinen Geschmack nicht, wenn "zuviel" von Klammern Gebrauch gemacht wird. Das kann zum Glück aber die CPU sehr zuverlässig.

Du schreibst "Wenn keine Klammern gesetzt sind, haben U Vorrang vor O" … oh nein!!! Eben nicht. Genau das ist wahrscheinlich ein Bisschen gewöhnungsbedürftig.

Du schreibst "Das was in Klammern steht wird zuerst berechnet. D.h. je weiter Verschachtelt ein Ausdruck seht, desto früher wird er verrechnet".
Nicht wirklich. Das wird über einen VKE-Stack geregelt - wie oben angedeutet - aber im Endeffekt ist die Wirkung genau so, wie man es erwartet. 

Das darfst Du als "BlackBox" betrachten, deren "Innereien" man nicht kennen muss.
Aber Du scheinst an diesem Thema sehr interessiert ... dann könntest Du Dir eine eigene "BlackBox" überlegen … nur so, als kleine TüftelAufgabe.
Frohes Gelingen ;o)

Gruss, Heinileini

PS:
Was ich beschrieben habe, gilt mit Sicherheit für eine Abarbeitung des AWL-Programms per Interpreter.
Ob und inwieweit heute bzw. zukünftig ein AWL-Programm per Compiler verwurstet wird, kann ich Dir nicht verraten. Dann wäre es schon denkbar, zuerst das am tiefsten Geschachtelte zu berechnen … (?) … und auch, eine Berechnung abzubrechen, sobald klar ist, dass die restlichen Terme das Ergebnis nicht mehr verändern können.


----------



## xxxyyyx (20 Mai 2018)

Ok.

Es ist mir igendwie noch nicht ganz klar, wie ich eine Ausdruck ohne Klammern und mit mehreren verschiedenen Operatoren deuten soll.
z.B.

```
UE 1.0
UE 1.1
UE 1.2
=A 1.1
-->Wenn alle Eingänge True sind, ist der Ausgang Ture sonst False
```


```
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
```


```
UE 1.0
UE 1.1
OE 1.2
OE 1.3
= A 1.1
--> ich habe keine Ahnung was dabei nun herauskommt :/
```


----------



## Heinileini (20 Mai 2018)

xxxyyyx schrieb:


> ```
> OE 1.0
> UE 1.1
> UE 1.2
> ...


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.


```
Ü   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?


----------



## xxxyyyx (20 Mai 2018)

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:

```
O   E 1.0
     O   E 1.1
     U   E 1.2
     U   E 1.3
```


----------



## Heinileini (20 Mai 2018)

Ja, "Aber dennoch sind Beispiel 1 und 2 gleich, richtig?" sind "identisch".


```
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   |
|-----[ ]----+
|
```


----------



## xxxyyyx (20 Mai 2018)

Ok, also kann man sich denken, dass (ohne Klammern und ohne reinen O Operator) einfach strikt von oben nach unten durchgegangen wird?


----------



## Heinileini (20 Mai 2018)

Genau! Sooo einfach ist das ;o)


----------



## xxxyyyx (20 Mai 2018)

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?


----------



## Heinileini (20 Mai 2018)

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.


----------



## xxxyyyx (21 Mai 2018)

Ok, dann nochmals vielen vielen Dank für deine Unterstützung!!!


----------

