For-Schleife und IF-Anweisung

matthias

Level-1
Beiträge
36
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

ich arbeite zurzeit an meiner Bachelorarbeit und habe große Probleme mit der Verbindung einer C7-621 ASI und einer S7-1200.
nachdem ich einige Verbindungsmöglichkeiten ausgeschlossen habe, bleibt mir nurnoch die Kommunikation über ASI-Module übrig. Die C7-621ASI ist direkt über die ASI-Leitung mit den ASI-Modulen verbunden. Die S7-1200 wird per eigitalen Ein und Ausgängen an die Module angeschlossen.
Da ich gerne einige Signale über diese ASI-Module senden will reicht es mit nicht einfach pro Kanal ein Signal zu übertragen. Deshalb will ich folgendes probieren:
Bsp:
Ich will das Signal von Sensor1, das von der C7 aufgenommen wird an die S7 übertragen.
1. Jedem Siganl wird ein binärer Code zugeordnet (der Sensor bekommt 00000101 das ist als Dezimalzahl eine 5)
2. Der letzte übertragene Sensorzustand wird in einem Merker gespeichert (Der Sensor in M 0.5). Der Sensor hängt an dem Eingang E 0.5.
3. In einer FOR-Schleife soll nun zuerst der aktuelle Sensorzustand mit dem gespeicherten Sensorzustand verglichen werden. Wenn die Werte ungleich sind soll das neue Signal übertragen werden (Der entsprechende Binärcode soll sich an den ASI-Modulen einstellen).

For (counter=1, counter >=128, counter +1) Da der Sensor die Nummer 5 bekommen hat soll er bei dem 5. Schleifendurchlauf kontrolliert werden
IF (E 0.5 > M 0.5){ das würde bedeuten, dass der Sensor von 0 auf 1 gewechselt hat
IF counter > 128 then A 0.0 = 1 und counter -128 else A 0.0 = 0
IF counter > 64 then A 0.1 = 1 und counter -64 else A 0.1 = 0
IF counter > 32 then A 0.2 = 1 und counter -32 else A 0.2 = 0
......
Hier wird die dezimale Zahl in eine Binärzahl umgerechnet und die Ausgänge der ASI-Module mit der binären Zahl belegt.
}
IF (E 0.5 < M 0.5){ das würde bedeuten, dass der Sensor von 1 auf 0 gewechselt hat
.... Fast analog zu oben
}

Ich hoffe ich konnte meine Idee halbwegs verständlich erklären.

Nun zu meinen Fragen:
1. Kann man in FUP in STEP7 überhaupt FOR-Schleifen und IF-Anweisungen erstellen (Ich hab über Google gehört das es mit dem MOVE-block funktionieren soll. Leider versteh ich nicht wie.)
2. Kann man in der FOR-Schleife die Werte der Merker und Eingänge laufen lassen:
Schleifendurchlauf1: Merker 0.0 und Eingang 0.0
Schleifendurchlauf2: Merker 0.1 und Eingang 0.1
Schleifendurchlauf3: Merker 0.2 und Eingang 0.2 ...



MfG Matthias
 
1. Kann man in FUP in STEP7 überhaupt FOR-Schleifen und IF-Anweisungen erstellen (Ich hab über Google gehört das es mit dem MOVE-block funktionieren soll. Leider versteh ich nicht wie.)
2. Kann man in der FOR-Schleife die Werte der Merker und Eingänge laufen lassen:
Schleifendurchlauf1: Merker 0.0 und Eingang 0.0
Schleifendurchlauf2: Merker 0.1 und Eingang 0.1
Schleifendurchlauf3: Merker 0.2 und Eingang 0.2 ...


1. FUP nein --->Dafür gibt es SCL

2. Ja

PS: Es kann mit Loop und Next auch eine Schleife in AWL gelöst werden
PSS: AWL -->Stichworte AR1,AR2 Pointer, indirekte Adressierung
 
Solange man mit der S7-1200 auch irgendwie If Anweisungen umsetzen kann ist es nicht schlimm.
Primär geht es mir um die Übertragung von der C7 zu der S7.

Noch eine Frage:
Die gesamte C7-621 ist mit FUP programmiert. Kann ich da einfach ein Stück AWL enfügen?
 
Das geht schon, du schaltest die Ansicht des ganzen Bausteins auf AWL um, fügst dein Netzwerk in ein programmierst es aus und schaltest anschließend wieder nach FUP um. Fertig
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich hab mal probiert mich in AWL einzuarbeiten und das Programm zum Senden der Signale zu erstellen.
Hab ich die AWL-Sprache halbwegs verstanden bzw. wird es so funktionieren. :confused:

Code:
Programm:
 
 
L                                    55                                                    [I]// Läd eine 55[/I]
SLD           3                                                                          [I]// Verschiebe 3 Stellen nach links [/I][I]à[/I][I] aus ..000.055 wird 55.0[/I]
T                                    #Zähler
L                                    0
T                                    #Zählersenden
 
Anfang:
 
L                                    0                                                       [I]// Setze alle Ausgänge=0[/I]
=                                    A 0.0
=                                    A 0.1
=                                    A 0.2
=                                    A 0.3
=                                    A 0.4
=                                    A 0.5
=                                    A 0.6
=                                    A 0.7
 
L                                    #Zähler
LAR1                                                                                     [I]// ???[/I]
L                                    DB1 [AR1,P#0.0]                           [I]// Läd den Inhalt des Bits 55.0 aus DB1[/I]
T                                    #GespeicherterWert                     [I]// Speichert das Ergebniss aus DB1 55.0 in #...[/I]
L                                    E [AR1,P#0.0]                                [I]// Läd den Zustand des Eingangs 55.0[/I] [I]?? Eingänge Reihe[/I]
T                                    #AktuellerWert                              [I]// Speichert den Zustand des Eingangs 55.0[/I]
X                                   #GespeicherterWert                      [I]// Vergleicht #Gesp mit #Aktu.[/I]
X                                   #AktuellerWert                              [I]// Vergleicht #Gesp mit #Aktu.[/I]
SPB                              Senden                                           [I]// Wenn #Gesp ungleich #Aktu ist, dann springe zu Senden[/I]
 
Weiter:
 
L                                    #Zähler
+AR1                                                                                     [I]// Addiere 1 mit 55.0 [/I][I]à[/I][I] 55.1[/I]
T                                    #Zähler
SPA                              Anfang
 
Senden:
 
L                                    #AktuellerWert                              [I]// Überprüft ob der aktuelle Wert=1 ist[/I]
L                                    1
==                                                                                          [I]// Wenn sich der Wert von 0 auf 1 geändert hat, dann ist das Ergebnis 1. Sonst ist es 0 (Der erste Wert der Binärzahl von Links gibt an ob das Signal 1 oder 0 ist. Die anderen sieben geben an um welches Signal es sich handelt.)[/I]
SPB                              SendenON                                     [I]// Wenn Ergebnis=1 dann Springe zu SendenON[/I]
 
L                                    1                                                       [I]// Setze Ausgang 0.0=1[/I]
=                                    A 0.0
 
SendenON:                                                                          [I]// Dezimalzahl>64 dann muss die 2. Stelle der Binärzahl 1 sein[/I]
L                                    #Zählersenden                             
L                                    64
>I
SPBN                           SendenON2
L                                    1
=                                    A 0.1
 
SendenON2:                                                                       [I]// (Dezimalzahl-64)>32 dann muss die 3. Stelle der Binärzahl 1 sein[/I]
L                                    #Zählersenden
L                                    64
-I
L                                    32
>I
SPBN                           SendenON3
L                                    1
=                                    A 0.2
SendenON3:                                                                       [I]// (Dezimalzahl-96)>16  dann muss die 4. Stelle der Binärzahl 1 sein[/I]
L                                    #Zählersenden
L                                    96
-I
L                                    16
>I
SPBN                           SendenON4
L                                    1
=                                    A 0.3
[I]// Analog fortfahren bis alle 8 Stellen der Binärzahl bestimmt sind[/I]
Senden ON8:
L                                    #Zählersenden
L                                    127
-I
L                                    16
>I
SPBN                           SendenON4
L                                    1
=                                    A 0.7
Pause                          10ms                            [I]// Pause damit die S7-1200 die ASI-Kanäle auslesen kann[/I]
SPA                              Weiter                          [I]// Springe zu Weiter[/I]
 
Zuletzt bearbeitet:
Nicht ganz. Simatic hat unter beispielprojekte hilfe. F1 auch. Siemens im www ausbildungsunterlagen zu awl.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
...
Nun zu meinen Fragen:
1. Kann man in FUP in STEP7 überhaupt FOR-Schleifen und IF-Anweisungen erstellen
...
1. FUP nein --->Dafür gibt es SCL
...
Natürlich kann man IF-Anweisungen und FOR-Schleifen auch in FUP/KOP erstellen!

1. Ist jede simple Zuweisung eine IF -Anweisung:
UND.jpg
entspricht:
IF E10.0=1 THEN A10.0=1 ELSE A10.0=0

Größere Verknüpfungen sind entsprechend größere IF-Anweisungen
Die Verknüpfung am Anfang entspricht dem IF-Block und der(die) folgende(n) Befehl(e) (SET, RESET, MOVE ...) dem THEN-Block. Negiert man den Eingang des Befehls, hat man einen ELSE-Block.



2. FOR-Schleifen legen einen Anfangswert fest, durchlaufen die Schleife, erhöhen am Ende die Variable um einen angegebene Schrittweite und vergleichen, ob sich das Ergebnis außerhalb des angegebenen Wertebereichs befindet. Wenn nicht, springen sie zum Beginn der Schleife zurück.
Und genau das kann man auch mit FUP/KOP erstellen:
For-Schleife.jpg


Ist zwar nicht so komfortabel, wie in SCL oder anderen höheren Programmiersprachen, aber die Frage war ja, ob man sowas erstellen kann.


PS: Ich hoffe, das mein FUP syntaktisch korrekt ist, ich benutz' das nie. Aber die Vorgehensweise sollte man auf jeden Fall erkennen können.
 
Zuletzt bearbeitet:
Schonmal danke für die Antworten.
Ich würde es zuerst mal mit AWL probieren.
Ich hab gerade mal nach den Ausbildungsunterlagen gesucht aber leider nichts gefunden.

Ich habe leider nur wenige und kurze Beispiele gefunden, mit denen ich mich nur schlecht in die AWL-Sprache hineindenken kann.
Es wäre deshalb eine riesen Hilfe, wenn ihr mir meine Fehler zeigen könntet, bzw mir sagt was ich grundlegend falsch mache.

MfG Matthias
 
Also erstmal sollte Dir bewußt sein, daß alles binär gespeichert und verarbeitet wird, egal in welcher Form du es angibst.

1.:
Bei L 55 steht also nicht 0.055 im Accu, sondern 0000 0000 0011 0111 (PS: was dann im Adressregister als 6.7 interpretiert wird).
Nach dem Linksschieben ist's dann 0000 0001 1011 1000 (was dann im Adressregister als 55.0 interpretiert wird).
War noch nicht wirklich falsch, aber man sollte wissen, was man macht.

2.:
Dann lädst Du 0 in den Accu, damit steht dort 0000 0000 0000 0000.
Das willst Du dem Ausgang A0.0 zuweisen (und danach A0.1, A0.2 ...) wie sollen denn in das eine Bit 16 Bitstellen passen?
Du hast zwei Möglichkeiten - entweder Du bringst das VKE auf 0, z.B. mit CLR und weist dies den Ausgängen zu:
Code:
CLR
= A 0.0
= A 0.1
PS2: Funktioniert zwar so, ist aber programmiertechnisch nicht schön - Zuweisungen von Ausgängen sollten nur an einer Stelle im Programm gemacht werden und nicht mehrfach, wie es hier wahrscheinlich nötig wäre.

oder Du transferierst die 0 auf das Ausgangsbyte/-word:
Code:
L 0
T AB 0


3.:
Mit z.B. "Anfang:" kann AWL nichts anfangen. Wenn es für Dich ein Kommentar sein soll, dann mußt Du es durch // für AWL kennzeichnen.
Soll's 'ne Sprungmarke sein:
F1 schrieb:
Die Sprungmarke kennzeichnet das Ziel einer Sprungoperation. Es besteht aus 4 Zeichen - erstes Zeichen: Buchstabe; restliche Zeichen: Buchstaben oder Zahlen; z.B. CAS1.


Reicht mir erst mal an Hinweisen. Schau Dir bitte wirklich erstmal die von verpolt PS: bzw. die von SoftMachine angegebenen Beispiele und Lernunterlagen an.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Nicht ganz. Simatic hat unter beispielprojekte hilfe. F1 auch.
Siemens im www ausbildungsunterlagen zu awl.
Ich hab gerade mal nach den Ausbildungsunterlagen gesucht aber leider nichts gefunden.

MfG Matthias
...
Reicht mir erst mal an Hinweisen. Schau Dir bitte wirklich erstmal die von verpolt angegebenen Beispiele und Lernunterlagen an.


Matthias,schau vielleicht mal hier:

http://www.automation.siemens.com/m...oad_ausbildungsunterlagen/Seiten/Default.aspx
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hey,

deine Steuerung wird dein Programm aber nicht verarbeiten könne. Bei den 1200er Steuerungen wird kein AWL unterstüzt!

Solange man mit der S7-1200 auch irgendwie If Anweisungen umsetzen kann ist es nicht schlimm.
Primär geht es mir um die Übertragung von der C7 zu der S7.

Noch eine Frage:
Die gesamte C7-621 ist mit FUP programmiert. Kann ich da einfach ein Stück AWL enfügen?

_________________________
 
Hallo Verpolt,

soweit ich das im Kopf hab ist die C7-621 doch eigentlich eine S7-300.

Korrigiert mich wenn ich da falsch gewickelt bin.
 
So Versuch NR.2 :D

EDIT:
  1. Sprungmarken berichtigt
  2. Für das Setzen der Ausgänge eine 0 erzeugt
  3. Verstanden, dass Zahlen binär gespeichert und verschoben werden (Hat nur an den Kommentaren was geändert)
  4. Ein Ende für die Schleife eingebaut (Sprungmarke End: )
Fragen:
  1. Normal werden die Ausgangswerte doch in das Prozessabbild geschrieben und gelangen von dort aus nach dem Programmzyklus an die Ausgänge. Ich müsste ja mehrmals im Programm meine Ausgänge verändern. geht das überhaupt?
  2. Was muss ich sonst noch verbessern?
MfG Matthias

Code:
Programm:
 
 
L                             55                                        [I]// Läd eine 110.111[/I]
SLD                         3                                          [I]// Verschiebe 3 Stellen nach links [/I][I]à[/I][I] 110111.000[/I]
T                             #Zaehler                               [I]// schreibe 110111.000 in #Zaehler[/I]
L                             0                                        [I]// Lade eine 0.000[/I]
T                             #Zaehlersenden                     [I]// schreibe 0.000 in #Zaehlersenden[/I]
 
Anf:                                                                       [I]// Anfang der Schleife[/I]
                                                              
L                             0                                             [I]//  erzeuge eine 0 weil 0<>1[/I]
L                             1                                             
==I
S                             A 0.0                                      [I]// Setze alle Ausgänge=0[/I]
S                             A 0.1
S                             A 0.2
S                             A 0.3
S                             A 0.4
S                             A 0.5
S                             A 0.6
S                             A 0.7
 
L                             #Zaehler                             [I]// Lade Zähler[/I]
LAR1                                                                [I]// keine Ahnung[/I]
L                             DB1 [AR1,P#0.0]                  [I]// Läd den Inhalt des Bits 55.0 aus DB1[/I]
T                             #GespeicherterWert              [I]// Speichert das Ergebniss aus DB1 55.0 in #...[/I]
L                             E [AR1,P#0.0]                      [I]// Läd den Zustand des Eingangs 55.0[/I] [I]?? Eingänge Reihe[/I]
T                             #AktuellerWert                    [I]// Speichert den Zustand des Eingangs 55.0[/I]
X                             #GespeicherterWert             [I]// Vergleicht #Gesp mit #Aktu.[/I]
X                             #AktuellerWert                    [I]// Vergleicht #Gesp mit #Aktu.[/I]
SPB                         Se0:                                  [I]// Wenn #Gesp ungleich #Aktu ist, dann springe zu Se0:[/I]
 
Mit:                                                                        [I]// Sprungmarke[/I]
 
L                             #Zaehler                                 [I]// Lade Zähler[/I]
+AR1                                                                    [I]// Addiere 1 mit 55.0 [/I][I]à[/I][I] 55.1[/I]
T                             #Zaehler                                 [I]// Speichere Wert in #Zaehler[/I]
L                             150                                        [I]// Lade eine [/I][I]10010110[/I]
SLD                          3                                          [I]// Verschiebe 3 Stellen nach links [/I][I]à[/I][I] 10010110.000[/I]
L                             #Zaehler                            
>                                                                         [I]//  wenn =1 dann Schleife beenden[/I]
SPB                        End:                                       [I]// Schleife beenden[/I]
SPA                       Anf:                                        [I]// Springe zum Anfang der Schleife[/I]
 
Se0:
 
L                             #AktuellerWert                    [I]// Überprüft ob der aktuelle Wert=1 ist[/I]
L                             1
==I                                                                          [I]// Wenn sich der Wert von 0 auf 1 geändert hat, dann ist das Ergebnis 1. Sonst ist es 0 (Der erste Wert der Binärzahl von Links gibt an ob das Signal 1 oder 0 ist. Die anderen sieben geben an um welches Signal es sich handelt.)[/I]
SPB                       Se1:                                       [I]// Wenn Ergebnis=1 dann Springe zu SendenON[/I]
 
NOT                                                                       [I]// Setze Ausgang 0.0=1[/I]
S                             A 0.0                                      [I]// Setze Ausgang 0.0=1[/I]
 
Se1:                                                                      [I]// Dezimalzahl >64 dann muss die 2. Stelle der Binärzahl 1 sein[/I]
L                             #Zaehlersenden                 
L                             64
>I
SPBN                    Se2:
S                             A 0.1
 
Se2:                                                                      [I]// (Dezimalzahl-64)>32 dann muss die 3. Stelle der Binärzahl 1 sein[/I]
L                             #Zaehlersenden
L                             64
-I
L                             32
>I
SPBN                    Se3:
S                             A 0.2
Se3:                                                                      [I]// (Dezimalzahl-96)>16  dann muss die 4. Stelle der Binärzahl 1 sein[/I]
L                             #Zaehlersenden
L                             96
-I
L                             16
>I
SPBN                    Se4:
S                             A 0.3
[I]// Analog fortfahren bis alle 8 Stellen der Binärzahl bestimmt sind[/I]
Se8:
L                             #Zaehlersenden
L                             127
-I
L                             0
>I
SPBN                    Se9:
S                             A 0.7
Se9:
Pause                    10ms                     [I]// Pause damit die S7-1200 die ASI-Kanäle auslesen kann[/I]
SPA                       Mit:                         [I]// Springe zu Weiter[/I]
End:
 
Zuletzt bearbeitet:
Warum fängst du nicht erstmal mit einfachen Grundlagen an und arbeitest Dich dann vor.

Als erstes solltest Du mal verstehen, dass das Programm zyklisch abgearbeitet wird. Das bedeutet je Zyklus einmal von Anfang bis Ende, dann werden die Ausgänge entprechend den errechneten Zuständen gesetzt/rückgesetzt, die Eingänge abgefragt und danach wieder das Programm durchgeackert. Es ist also nicht wie bei einem PC-Programm, wo Du dafür sorgen mußt, das das Programm nicht zu Ende läuft. Sogar im Gegenteil - das Programm muss zum Ende kommen, weil ja sonst nichts an Deinen Ausgängen passiert bzw. die Eingänge nicht abgefragt/aktualisiert werden, wenn Du in einer Programmschleife festhängst.


Dann dürfen Sprungmarken nicht alleine in einer Zeile stehen, sondern immer vor einem Befehl. Soll kein Befehl folgen, gibt es die Leerlaufanweisung "NOP 0".
Die Doppelpunkte gehören nicht zum Namen der Sprungmarke, sondern kennzeichnen diese. Beim Sprungbefehl werden diese also nicht mit angegeben.


Ausgängen kann man einen Zustand zuweisen oder sie dauerhaft setzen bzw. rücksetzen.
Code:
U E 0.0
= A 0.0
Mit = folgt in diesem Fall der Ausgang A0.0 immer dem Zustand von E0.0 (wie bei einem Schalter). Ist E0.0 ein, ist auch A0.0 ein - ist E0.0 aus, ist auch A0.0 aus.
Code:
U E 0.0
S A 0.0
Hier wird der Ausgang A0.0 dauerhaft auf EIN gesetzt, sobald der Eingang E0.0 einmal auf EIN geht. Auch wenn der Eingang dann wieder aus geht. Also wie ein Schütz mit Selbsthaltung.
Code:
U E 0.1
R A 0.0
Erst hier wird bei Betätigung eines weiteren Taster (o.ä.) der Ausgang wieder dauerhaft zurückgesetzt.
Also zusammengefaßt: Setzen ist immer EIN und Rücksetzen ist immer AUS.
Alle drei Varianten stellen eine bitweise Bearbeitung dar.

Man kann die Ausgänge aber auch byte-, word- oder doppelwordweise bearbeiten. Das Ausgangsbyte AB0 z.B. kann dann 256 Zustände haben, jenachdem welchen Zustand die einzelnen 8 Bits haben. Das kann man nutzen, um z.B. einen Zustand, wie alle Bits aus, schnell zuzuweisen:
Code:
L 0
T AB 0
Damit erhalten die Bits A0.0 bis A0.7 alle den Zustand 0.


== gibt es nicht als Anweisung. Jeder Vergleich beinhaltet in der Anweisung auch immer den Datentyp, der verglichen werden soll, also zb. ==I oder ==D


Pause als Anweisung gibt es meines Wissens nach nicht.

Wie gesagt, ist dies hier ein SPS-Programm, das zyklisch durchgearbeitet wird. Wenn die Eingänge nicht in diesem Zyklus als gesetzt abgearbeitet werden, dann halt im nächsten. Einen Zustand haben sie aber immer entweder 0 oder 1, egal wie lange die Abfrage dauert.



Frage: Womit schreibst Du denn Dein Programm? Einfach so mit dem PC-Editor?
Step 7 hätte doch bei all dem aufgezählten schon "gemeckert" und ich hab' mir nicht mal angesehen, was das Programm eigentlich machen soll. (Ist mir heut' zuviel für'n Feierabend.)
 
Zuletzt bearbeitet:
Zurück
Oben