Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 3 von 3 ErsteErste 123
Ergebnis 21 bis 29 von 29

Thema: For-Schleife und IF-Anweisung

  1. #21
    Registriert seit
    26.06.2012
    Beiträge
    36
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    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

  2. #22
    Registriert seit
    22.11.2006
    Ort
    CH
    Beiträge
    3.620
    Danke
    777
    Erhielt 647 Danke für 493 Beiträge

    Standard

    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é

  3. #23
    Registriert seit
    26.06.2012
    Beiträge
    36
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    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

  4. #24
    Registriert seit
    22.11.2006
    Ort
    CH
    Beiträge
    3.620
    Danke
    777
    Erhielt 647 Danke für 493 Beiträge

    Standard

    Zitat Zitat von matthias Beitrag anzeigen
    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é

  5. #25
    Registriert seit
    26.06.2012
    Beiträge
    36
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    (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                                          // Läd eine 110.111
    SLD        3                                                            // Verschiebe 3 Stellen nach links à 110111.000
    T                             #Zaehler                               // schreibe 110111.000 in #Zaehler
    L                             0                                             // Lade eine 0.000
    T                             #Zaehlersenden                      // schreibe 0.000 in #Zaehlersenden
     
    Anf:                                                                       // Anfang der Schleife
                                                                  
    L                             1                                             //  erzeuge eine 0 weil 0<>1
    L                             1                                             
    ==I
    R                             A 0.0                                      // Setze alle Ausgänge=0
    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                               // Lade Zähler
    LAR1                                                                    // keine Ahnung
    L                             DB1 [AR1,P#0.0]                 // Läd den Inhalt des Bits 55.0 aus DB1
    T                             #GespeicherterWert           // Speichert das Ergebniss aus DB1 55.0 in #...
    L                             E [AR1,P#0.0]                      // Läd den Zustand des Eingangs 55.0 ?? Eingänge Reihe
    T                             #AktuellerWert                    // Speichert den Zustand des Eingangs 55.0
    X                             #GespeicherterWert           // Vergleicht #Gesp mit #Aktu.
    X                             #AktuellerWert                    // Vergleicht #Gesp mit #Aktu.
    SPB                       Se0                                        // Wenn #Gesp ungleich #Aktu ist, dann springe zu Se0:
     
    Mit:                                                                        // Sprungmarke
     
    L                             #Zaehler                               // Lade Zähler
    +AR1                                                                    // Addiere 1 mit 55.0 à 55.1
    T                             #Zaehler                               // Speichere Wert in #Zaehler
    L                             150                                        // Lade eine 10010110
    SLD        3                                                            // Verschiebe 3 Stellen nach links à 10010110.000
    L                             #Zaehler                            
    <I                                                                          //  wenn =1 dann Schleife beenden
    SPB                        End                                       // Schleife beenden
    SPA                       Anf                                         // Springe zum Anfang der Schleife
     
    Se0:
     
    L                             #AktuellerWert                    // Überprüft ob der aktuelle Wert=1 ist
    L                             0
    ==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.)
    S                             A 0.0                                      // Setze Ausgang 0.0=1
     
    L                             #Zaehlersenden                 // Dezimalzahl >64 dann muss die 2. Stelle der Binärzahl 1 sein
     
    L                             64
    >I
    S                             A 0.1                                                     
    L                             #Zaehlersenden                 // (Dezimalzahl-64)>32 dann muss die 3. Stelle der Binärzahl 1 sein
    L                             64
    -I
    L                             32
    >I
    S                             A 0.2                                      
    L                             #Zaehlersenden                 // (Dezimalzahl-96)>16  dann muss die 4. Stelle der Binärzahl 1 sein
    L                             96
    -I
    L                             16
    >I
    S                             A 0.3
    // Analog fortfahren bis alle 8 Stellen der Binärzahl bestimmt sind
    L                             #Zaehlersenden
    L                             127
    -I
    L                             0
    >I
    S                             A 0.7
    SPA                       Mit                          // Springe zu Weiter
    End:

  6. #26
    Registriert seit
    22.11.2006
    Ort
    CH
    Beiträge
    3.620
    Danke
    777
    Erhielt 647 Danke für 493 Beiträge

    Standard

    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é

  7. #27
    Registriert seit
    26.06.2012
    Beiträge
    36
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    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

  8. #28
    Registriert seit
    19.06.2008
    Ort
    Ostalbkreis
    Beiträge
    3.140
    Danke
    201
    Erhielt 553 Danke für 498 Beiträge

    Standard

    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

  9. #29
    Registriert seit
    26.06.2012
    Beiträge
    36
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    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                                          // Läd eine 110.111
    SLD        3                                                            // Verschiebe 3 Stellen nach links à 110111.000
    T                             #Zaehler                               // schreibe 110111.000 in #Zaehler
    L                             0                                             // Lade eine 0.000
    T                             #Zaehlersenden                 // schreibe 0.000 in #Zaehlersenden
     
    Anf:                                                                       // Anfang der Schleife
                                                                  
     
    L                             #Zaehler                               // Lade Zähler
    LAR1                                                                    // keine Ahnung
    L                             DB1 [AR1,P#0.0]                 // Läd den Inhalt des Bits 55.0 aus DB1
    T                             #GespeicherterWert           // Speichert das Ergebniss aus DB1 55.0 in #...
    L                             E [AR1,P#0.0]                      // Läd den Zustand des Eingangs 55.0 ?? Eingänge Reihe
    T                             #AktuellerWert                    // Speichert den Zustand des Eingangs 55.0
    X                             #GespeicherterWert           // Vergleicht #Gesp mit #Aktu.
    X                             #AktuellerWert                    // Vergleicht #Gesp mit #Aktu.
    SPB                       Se0                                        // Wenn #Gesp ungleich #Aktu ist, dann springe zu Se0:
     
    Mit:                                                                        // Sprungmarke
     
    L                             #Zaehler                               // Lade Zähler
    +AR1                                                                    // Addiere 1 mit 55.0 à 55.1
    T                             #Zaehler                               // Speichere Wert in #Zaehler
    L                             150                                        // Lade eine 10010110
    SLD        3                                                            // Verschiebe 3 Stellen nach links à 10010110.000
    L                             #Zaehler                            
    <I                                                                          //  wenn =1 dann Schleife beenden
    SPB                        End                                       // Schleife beenden
    SPA                       Anf                                         // Springe zum Anfang der Schleife
     
     
     
     
    Se0:
     
    SET                                                                       
    R                             A 0.0                                      // Setze alle Ausgänge=0
    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                    // Überprüft ob der aktuelle Wert=1 ist
    L                             0
    ==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.)
    S                             A 0.0                                      // Setze Ausgang 0.0=1
     
    L                             #Zaehlersenden                 // Dezimalzahl >64 dann muss die 2. Stelle der Binärzahl 1 sein
     
    L                             64
    >I
    S                             A 0.1                                                      
    L                             #Zaehlersenden                 // (Dezimalzahl-64)>32 dann muss die 3. Stelle der Binärzahl 1 sein
    L                             64
    -I
    L                             32
    >I
    S                             A 0.2                                      
    L                             #Zaehlersenden                 // (Dezimalzahl-96)>16  dann muss die 4. Stelle der Binärzahl 1 sein
    L                             96
    -I
    L                             16
    >I
    S                             A 0.3
    // Analog fortfahren bis alle 8 Stellen der Binärzahl bestimmt sind
    L                             #Zaehlersenden
    L                             127
    -I
    L                             0
    >I
    S                             A 0.7
    T                             #GespeicherterWert           // Speichert das Ergebniss aus DB1 55.0 in #...
    L                             #AktuellerWert                     // Läd den aktuellen Wert
    T                             #GespeicherterWert             // Überschreibt den gespeicherten Zustand mit dem aktuellen Zustand
    End:
    Geändert von matthias (01.07.2012 um 15:33 Uhr)

Ähnliche Themen

  1. SCL und If-Anweisung
    Von steven001 im Forum Programmierstrategien
    Antworten: 33
    Letzter Beitrag: 09.06.2012, 17:54
  2. Antworten: 23
    Letzter Beitrag: 12.06.2011, 07:30
  3. awl schleife und pointer
    Von Iserlohner im Forum Simatic
    Antworten: 28
    Letzter Beitrag: 18.02.2011, 09:12
  4. Anweisung ?
    Von Xaverl im Forum Simatic
    Antworten: 2
    Letzter Beitrag: 06.01.2010, 14:29
  5. SCL-Compiler und Case-Anweisung
    Von herdi im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 10.09.2008, 10:02

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •