For-Schleife und IF-Anweisung

matthias · 28 Juni 2012

Hallo,

das setzen meiner Ausgänge müsste doch so funktionieren.
Zuerst Setze ich alle=0
danach werden nur die die 1 annehmen sollen gleich 1 gesetzt. (Alles mit S AX.X)

Das mit dem zyklischen Abarbeiten wusste ich. Ich bin aber davon ausgegangen, dass man auch mehrmals in einem Zyklus den gleichen Ausgang setzen kann.
(Eingänge konnte man doch auch unabhängig von dem Prozessabbild in einem Zyklus einlesen)

In welchen Bereichen liegt denn eine normale Zykluszeit. (Liegt sie unter 1ms, zwischen 10-100ms, oder auch mehrere Sekunden).
Wenn sie nicht allzu groß ist, kann ich ja auch die Zyklusdurchläufe als Schleife verwenden. (Dann sende ich pro Zyklus 1 Signal)
Ich werde mal probieren die Zykluszeit der C7 zu messen.

Hinter dem == hab ich das I vergessen. (Werds editieren)
Die Pause wollte ich durch wait ersetzen (Wenns nötig ist dort eine Pause zu machen).

Danke für die vielen Hinweise.

MfG Matthias

vollmi · 28 Juni 2012

In einer SPS macht man keine Pause. Man überspringt ggfs eine Bearbeitung wenn eine Zeitlang mit dieser abgewartet werden soll und lässt das Programm in dieser Zeit was anderes tun.

Die Eingänge werden am Anfang eines Zyklus eingelesen. Während des Zyklus ändern sie sich nicht mehr, können aber natürlich mehrmals abgefragt werden. Das Ergebnis ist aber immer dasselbe.

Ausgänge werden ebenfalls am ende eines Zyklus effektiv an die Hardware ausgegeben. Du kannst sie mehrmals im Zyklus beschreiben. Aber der letzte Schrieb des Zyklus zählt dann für die Hardware.

Mit S setzt man Bit (Ausgänge, Merker und dergleichen) immer nur auf 1 niemals auf 0. Und auf 1 wird nur bei erfüllter Vorbedingung gesetzt.

Auf Null setzt man mit R ebenfalls nur bei erfüllter Vorbedingung.

Und das = schreibt einfach das Ergebnis der vorhergehenden Abfrage auf die Zuweisung (z.B. der Ausgang). Ist das Ergebnis 0 dann wird der Ausgang 0 ist das Ergebnis 1 dann wird der Ausgang 1. Das findet dann immer statt, es seidenn die Anweisung wird übersprungen.

mfG René

matthias · 28 Juni 2012

Code:

L                             #Zaehlersenden                 
L                             64
>I
S                             A 0.1

Also wird A 0.1 nur =1 wenn die Bedingung #Zaehlersenden>64 erfüllt ist. Sonst verbleibt der Ausgang auf 0. (A0.1 wurde ja am Anfang des Programms auf 0 gesetzt)
Habe ich das richtig verstanden? Dann kann ich mir fast alle meiner Sprungmarken sparen

Kann man am PC irgendwie die Zykluszeit der C7 bestimmen? (Die anderen Methoden sehen kompliziert aus

)

MfG Matthias

vollmi · 28 Juni 2012

matthias schrieb:
Code:

L #Zaehlersenden L 64 >I S A 0.1

Also wird A 0.1 nur =1 wenn die Bedingung #Zaehlersenden>64 erfüllt ist. Sonst verbleibt der Ausgang auf 0.

So ist es. Wenn die Bedingung nicht erfüllt ist wird der Ausgang nicht verändert. 1 bleibt 1 0 bleibt 0.

(A0.1 wurde ja am Anfang des Programms auf 0 gesetzt)

Nö, zumindest nicht in dem Programm das du gepostet hast. Da hast du nur S auf die Ausgänge angewendet.

Kann man am PC irgendwie die Zykluszeit der C7 bestimmen? (Die anderen Methoden sehen kompliziert aus )

Kenne die C7 leider nicht. Aber ich vermute stark das die Zykluszeit stark vom Prozessor der im Hintergrund werkelt abhängig ist. Aber um die würde ich mir an deiner stelle erstmal so garkeine Sorgen machen.

mfG René

matthias · 28 Juni 2012

(A0.1 wurde ja am Anfang des Programms auf 0 gesetzt) Nö, zumindest nicht in dem Programm das du gepostet hast. Da hast du nur S auf die Ausgänge angewendet.

Stimmt natürlich

(Habs bei mir auf dem PC schon geändert)

Die Grundlage für die C7-621ASI bildet eine CPU 314 (http://www.tecnodrive.com.br/Folheto_C7.pdf)
Kann man dadurch die Zykluszeit bei nem normalen Programm schätzen?

Hier noch der überarbeitete Code:

Code:

Programm:
(Hinter den Sprungmarken steht noch nichts, weil sonst die Formatierung noch schwiriger wird :D)
 
 
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                             1                                             [I]//  erzeuge eine 0 weil 0<>1[/I]
L                             1                                             
==I
R                             A 0.0                                      [I]// Setze alle Ausgänge=0[/I]
R                             A 0.1
R                             A 0.2
R                             A 0.3
R                             A 0.4
R                             A 0.5
R                             A 0.6
R                             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                                                                          [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                             0
==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]
S                             A 0.0                                      [I]// Setze Ausgang 0.0=1[/I]
 
L                             #Zaehlersenden                 [I]// Dezimalzahl >64 dann muss die 2. Stelle der Binärzahl 1 sein[/I]
 
L                             64
>I
S                             A 0.1                                                     
L                             #Zaehlersenden                 [I]// (Dezimalzahl-64)>32 dann muss die 3. Stelle der Binärzahl 1 sein[/I]
L                             64
-I
L                             32
>I
S                             A 0.2                                      
L                             #Zaehlersenden                 [I]// (Dezimalzahl-96)>16  dann muss die 4. Stelle der Binärzahl 1 sein[/I]
L                             96
-I
L                             16
>I
S                             A 0.3
[I]// Analog fortfahren bis alle 8 Stellen der Binärzahl bestimmt sind[/I]
L                             #Zaehlersenden
L                             127
-I
L                             0
>I
S                             A 0.7
SPA                       Mit                          [I]// Springe zu Weiter[/I]
End:

vollmi · 28 Juni 2012

Wenn du uns noch "normal" definierst dann kann dir sicher jemand die Zykluszeit schätzen.

Da du aber nur schon die grundlegenden Sachen ziemlich umständlich Programmierst dürfte deine Zykluszeit ziemlich abwandern von "normal"

Nur schon das
L 1
L 1
==I
um ein VKE = 1 zu bilden.
Wennschon dann nimmt man dazu ein SET denn das sind schon Bruchteile der benötigten Bearbeitungszeit einer arithmetischen Abfrage.

mfG René

matthias · 28 Juni 2012

Die Anlage die von der C7 gesteuert wird, besitzt ca. 15Aktoren (über ASI) und 20 Sensoren (über ASI). Die Sensordaten werden im Programm alle verarbeitet.
Kann man aus diesen Daten eine ganz grobe Schätzung treffen?
Der Bereich in dem man sich bewegt würde auch reichen (Sind es eher 1Sekunde, 500ms, 100ms, 10ms ..)

Nur schon das
L 1
L 1
==I
um ein VKE = 1 zu bilden.
Wennschon dann nimmt man dazu ein SET denn das sind schon Bruchteile der benötigten Bearbeitungszeit einer arithmetischen Abfrage.

Habs schon geändert

MfG Matthias

Verpolt · 28 Juni 2012

ASI A-Kanal (1-32 Inseln a' 4E oder 4A) = ~ 5ms Aktualisierung

Das Programm dazu

tippe ich auf unter 10 ms auf einer S7-300

matthias · 1 Juli 2012

Hallo,

ich habe das Programm nochmals überarbeitet und es leicht abgeändert:
Die C7-621 sucht alle gewünschten Eingänge der Reihe nach ab, bis sie einen findet, der sich geändert hat.
Danach stellt sie an den acht Ausgängen der ASI-Module den binären Code für das geänderte Signal ein.

Ist der Code so fehlerfrei?
Bleiben die gespeicherten Daten (z.B. #gespeicherterWert) auch für den nächsten Zyklus vorhanden?

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                             #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                                                                          [I]//  wenn =1 dann Schleife beenden[/I]
SPB                        End                                       [I]// Schleife beenden[/I]
SPA                       Anf                                         [I]// Springe zum Anfang der Schleife[/I]
 
 
 
 
Se0:
 
SET                                                                       
R                             A 0.0                                      [I]// Setze alle Ausgänge=0[/I]
R                             A 0.1
R                             A 0.2
R                             A 0.3
R                             A 0.4
R                             A 0.5
R                             A 0.6
R                             A 0.7
 
L                             #AktuellerWert                    [I]// Überprüft ob der aktuelle Wert=1 ist[/I]
L                             0
==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]
S                             A 0.0                                      [I]// Setze Ausgang 0.0=1[/I]
 
L                             #Zaehlersenden                 [I]// Dezimalzahl >64 dann muss die 2. Stelle der Binärzahl 1 sein[/I]
 
L                             64
>I
S                             A 0.1                                                      
L                             #Zaehlersenden                 [I]// (Dezimalzahl-64)>32 dann muss die 3. Stelle der Binärzahl 1 sein[/I]
L                             64
-I
L                             32
>I
S                             A 0.2                                      
L                             #Zaehlersenden                 [I]// (Dezimalzahl-96)>16  dann muss die 4. Stelle der Binärzahl 1 sein[/I]
L                             96
-I
L                             16
>I
S                             A 0.3
[I]// Analog fortfahren bis alle 8 Stellen der Binärzahl bestimmt sind[/I]
L                             #Zaehlersenden
L                             127
-I
L                             0
>I
S                             A 0.7
T                             #GespeicherterWert           [I]// Speichert das Ergebniss aus DB1 55.0 in #...[/I]
L                             #AktuellerWert                     [I]// Läd den aktuellen Wert[/I]
T                             #GespeicherterWert             [I]// Überschreibt den gespeicherten Zustand mit dem aktuellen Zustand[/I]
End:

For-Schleife und IF-Anweisung

matthias

Level-1

vollmi

Level-3

matthias

Level-1

vollmi

Level-3

matthias

Level-1

vollmi

Level-3

matthias

Level-1

Verpolt

Level-1

matthias

Level-1

Similar threads

Wir schützen deine Privatsphäre