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

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 21

Thema: SCL vs. AWL

  1. #1
    Registriert seit
    01.10.2009
    Beiträge
    19
    Danke
    15
    Erhielt 2 Danke für 2 Beiträge

    Frage


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hi,

    ich habe den selben Baustein in AWL und in SCL erstellt.
    Beide Funktionieren gleich.
    Doch obwohl der SCL Baustein einen viel kürzeren Code als der AWL Baustein hat,
    braucht dieser trotzdem doppelt soviel Speicher und ist zudem auch noch langsamer (höhere CPU Zykluszeit).

    Woran liegt das ?
    Ist es dann nicht besser nur in AWL zu Programmieren ?
    Oder habe ich beim übersetzen was falsch gemacht ?

    Vieleicht kann mir da jemand weiterhelfen.

    Gruß
    Epy
    Angehängte Dateien Angehängte Dateien
    Zitieren Zitieren SCL vs. AWL  

  2. #2
    Registriert seit
    25.06.2007
    Ort
    Dresden
    Beiträge
    3.930
    Danke
    465
    Erhielt 878 Danke für 634 Beiträge

    Standard

    Du musst dir den Ergenbiscode
    generiert vom SCL Übersetzer Version: SCLCOMP K05.03.05.00_01.03.00.01 release
    anschauen.

    Code:
          SET   
          SAVE  
          =     L      2.1
          L     0
          T     #Index
          L     #Anzahl_Stoerungs_DW
          L     1
          -I    
          SPO   I007
          SPA   I008
    I007: CLR   
          =     L      2.1
    I008: L     2
          *I    
          SPO   I009
          SPA   I00a
    I009: CLR   
          =     L      2.1
    I00a: L     0
          T     #Index
          TAK   
          T     LW     4
          TAK   
    A7d0: L     #Index
          L     LW     4
          <=I   
          SPBN  A7d1
          L     #Index
          ITD   
          L     L#8
          *D    
          SPO   I00b
          SPA   I00c
    I00b: CLR   
          =     L      2.1
    I00c: AUF   #DB_Stoerung
          LAR1  
          L     DBW [AR1,P#0.0]
          L     W#16#0
          <>I   
          SPBN  A7d2
          SET   
          =     #Stoerung
    A7d2: L     #Anzahl_Stoerungs_DW
          L     2
          *I    
          SPO   I00d
          SPA   I00e
    I00d: CLR   
          =     L      2.1
    I00e: L     #Index
          +I    
          SPO   I00f
          SPA   I010
    I00f: CLR   
          =     L      2.1
    I010: ITD   
          L     L#8
          *D    
          SPO   I011
          SPA   I012
    I011: CLR   
          =     L      2.1
    I012: L     #Index
          ITD   
          TAK   
          T     LD     6
          TAK   
          L     L#8
          *D    
          SPO   I013
          SPA   I014
    I013: CLR   
          =     L      2.1
    I014: AUF   #DB_Stoerung
          LAR1  
          L     DBW [AR1,P#0.0]
          L     W#16#FFFF
          XOW   
          LAR1  LD     6
          T     DBW [AR1,P#0.0]
          L     #Index
          L     2
          +I    
          SPO   I015
          SPA   I016
    I015: CLR   
          =     L      2.1
    I016: T     #Index
          SPA   A7d0
    A7d1: CLR   
          U     #Stoerung_loeschen
          SPBN  A7d3
          L     0
          T     #Index
          L     #Anzahl_Stoerungs_DW
          L     1
          -I    
          SPO   I017
          SPA   I018
    I017: CLR   
          =     L      2.1
    I018: L     2
          *I    
          SPO   I019
          SPA   I01a
    I019: CLR   
          =     L      2.1
    I01a: L     0
          T     #Index
          TAK   
          T     LW     4
          TAK   
    A7d4: L     #Index
          L     LW     4
          <=I   
          SPBN  A7d5
          L     #Index
          ITD   
          L     L#8
          *D    
          SPO   I01b
          SPA   I01c
    I01b: CLR   
          =     L      2.1
    I01c: L     W#16#0
          AUF   #DB_Stoerung
          TAK   
          LAR1  
          TAK   
          T     DBW [AR1,P#0.0]
          L     #Index
          L     2
          +I    
          SPO   I01d
          SPA   I01e
    I01d: CLR   
          =     L      2.1
    I01e: T     #Index
          SPA   A7d4
    A7d5: CLR   
          =     #Stoerung
    A7d3: CLR   
          U     L      2.1
          SAVE  
          BE
    wieviel langsamer ist den die SCL-Variante?

    Aber bitte alles BEOBACHTEN ausschalten!!!

    Frank
    Grüße Frank

  3. Folgender Benutzer sagt Danke zu IBFS für den nützlichen Beitrag:

    epy (02.09.2010)

  4. #3
    Avatar von epy
    epy ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    01.10.2009
    Beiträge
    19
    Danke
    15
    Erhielt 2 Danke für 2 Beiträge

    Rotes Gesicht

    Wow...
    Das mit der Zykluszeit mach ich morgen gleich.

    Aber wie komm ich an den AWL Code nach dem SCL Übersetzen ?

    Danke schon mal.

  5. #4
    Registriert seit
    25.06.2007
    Ort
    Dresden
    Beiträge
    3.930
    Danke
    465
    Erhielt 878 Danke für 634 Beiträge

    Standard

    Zitat Zitat von epy Beitrag anzeigen
    Doch obwohl der SCL Baustein einen viel kürzeren Code als der AWL Baustein hat,...
    er hat einen übersichtlicher dargestellten Code!

    Ich habe es an anderer Stelle auch schon ähnlich geschrieben:

    Nur bei S7 gibt es überhaupt die Möglichkeit, denn generierten
    Code und die Codegröße überhaupt zu vergleichen. Das ist interessant
    legitim und lehreich. Aber das über die "in AWL gewandelten Ergebinsse"
    immer so ein Brimborium gemacht wird, ist mir schleierhaft.

    Außer bei kleiner SPS-Gruken, wo es auf jede "ms" ankommt ist mir das
    Aussehen des AWL-Zielcodes völlig egal, hautpsache er funktioniert.
    Und pflegeleichter ist SCL allemal, aber das soll jeder selbst entscheiden.

    Frank
    Grüße Frank

  6. #5
    Registriert seit
    20.11.2006
    Ort
    Hamburg
    Beiträge
    225
    Danke
    35
    Erhielt 35 Danke für 32 Beiträge

    Standard

    Jetzt mal unabhängig von der Frage.

    In der SCL-Quelle wird der Ausgang Stoerung nicht immer definiert.
    Code:
    FUNCTION FC75 : VOID
    TITLE = 'Störungen auswerten'
    VAR_INPUT
        DB_Stoerung : BLOCK_DB;
        Anzahl_Stoerungs_DW : INT; 
        Stoerung_loeschen : BOOL;
       END_VAR
    VAR_OUTPUT
        Stoerung : BOOL;
    END_VAR
    VAR_TEMP
       Index : INT;
    END_VAR
     
    Stoerung := FALSE;  // Ausgangsvariable initialisieren
    // Abfrage ob Störungbit vorhaden
    Index := 0;
        FOR Index := 0 TO ((Anzahl_Stoerungs_DW-1)*2) BY 2 DO
             IF DB_Stoerung.DW[Index] <> 0 THEN
                Stoerung := true;
             END_IF; 
          // Quittierbereich des DB´s invertiren          
          DB_Stoerung.DW[(Anzahl_Stoerungs_DW*2)+Index] := DB_Stoerung.DW[Index] XOR 16#FFFF;        
        END_FOR;
    //Störmeldebits löschen 
        IF Stoerung_loeschen = True THEN
               Index := 0;
                     FOR Index := 0 TO (Anzahl_Stoerungs_DW-1)*2 BY 2 DO
                        DB_Stoerung.DW[Index]:= 0; 
                     END_FOR;
               Stoerung := False;
        END_IF;
      END_FUNCTION
    In der AWL-Quelle wird lesend auf den Ausgang Stoerung zugegriffen.
    Code:
    FUNCTION "Störungen auswerten" : VOID
    TITLE =STÖRUNGEN AUSWERTEN                                         
    //###############################################################################
    //#####                                                                     #####
    //#####                        STÖRUNGEN AUSWERTEN                          #####
    //#####                                                                     #####
    //###############################################################################
    //
    //EINGANGSPARAMETER:
    //==================
    //  DB_Störungen        - Datenbaustein in dem die Störungsbits beschrieben werden
    //  Störung_löschen     - Alle Störungen werden gelöscht                         
    //  Anzahl_Störungs_DW  - Anzahl der Datenworte für Störungen      
    //                      
    //AUSGANGSPARAMETER:
    //==================
    //  Störung             - Störung im Datenbaustein gefunden 
    //  
    //WIRKUNGSWEISE :
    //===============
    //Es werden die einzelnen Bits auf 'true' in einem Datenbaustein überwacht. 
    //Wurde mindestes ein Bit auf 'true' gesetzt so wird der Ausgang Störung gesetzt. 
    //Mit dem Eingangsparameter 'STÖRUNG LÖSCHEN' werden alle Bits auf 'false' 
    //gesetzt u7nd der Ausgangsparameter 'STÖRUNG' wird gelöscht.
    //Es wird die Anzahl der Störungs Datenwörter überwacht. Im direkten Anschluss 
    //muß sich der Quittierungsbereich mit der gleichen Anzahl Datenwörter befinden. 
    //Die Bits des Quittierungsbereiches werden automatisch invertiert. 
    // 
    //z.B.: Datenbaustein für Störungen DB123 
    //      Anzahl Störungs Datenwörter = 5
    //      Länge des Datenbausteins = 20 
    //
    //DW 0: Störungen 1
    //DW 2: Störungen 2
    //DW 4: Störungen 3
    //DW 6: Störungen 4
    //DW 8: Störungen 5
    //DW10: Quittierbereich Störungen 1
    //DW12: Quittierbereich Störungen 2
    //DW14: Quittierbereich Störungen 3
    //DW16: Quittierbereich Störungen 4
    //DW18: Quittierbereich Störungen 5 
    VERSION : 0.1
    VAR_INPUT
      DB_Stoerungen : BLOCK_DB ;    //Datenbaustein der ausgewertet wird
      Anzahl_Stoerungs_DW : INT ;   //Anzahl der Störungen in Datenworten
      Stoerung_loeschen : BOOL ;    //Taster Störung löschen
    END_VAR
    VAR_OUTPUT
      Stoerung : BOOL ;             //Störung vorhanden
    END_VAR
    VAR_TEMP
      Schleifenzaehler : WORD ; 
      DB_Register : WORD ; 
      AR1_Register : DWORD ; 
      AR2_Register : DWORD ; 
      Anzahl_Dword : INT ; 
      Word_vorhanden : BOOL ; 
    END_VAR
    BEGIN
    NETWORK
    TITLE =Register sichern
          L     DBNO;           //Aktuellen DB sichern
          T     #DB_Register; 
          TAR1  ;               //Adressregister 1 sichern
          T     #AR1_Register; 
          TAR2  ;               //Adressregister 2 sichern
          T     #AR2_Register; 
    NETWORK
    TITLE =Daten aufbereiten
          AUF   #DB_Stoerungen; //Datenbaustein aufschlagen
    //Erstes Störungs-DW in Adressregister 1
          L     P#0.0; 
          LAR1  ; 
    //Erstes Quittier-DW in Adressregister 2
          L     #Anzahl_Stoerungs_DW; 
          ITD   ; 
          SLD   4; 
          LAR2  ; 
    //Anzahl Doppelworte berechnen
          L     #Anzahl_Stoerungs_DW; 
          SRW   1; 
          T     #Anzahl_Dword; 
    //Anzahl Doppelworte ungleich  
          L     #Anzahl_Stoerungs_DW; 
          L     1; 
          UW    ; 
          L     1; 
          ==I   ; 
          =     #Word_vorhanden; 
    //Schleifenzaehler initialisieren
          L     0; 
          T     #Schleifenzaehler; 
    //Wenn Störung vorhanden zum Quittierbereich
          U     #Stoerung; // lesend auf Ausgang zugegriffen
          U     #Stoerung_loeschen; 
          SPB   QUIT; 
    NETWORK
    TITLE =Schleife Störung auswerten und Quittierbereich Invertieren
          L     #Anzahl_Dword;      //Anzahl der Doppelworte
    GO1:  T     #Schleifenzaehler;  //in Schleifenzähler laden 
          L     DBD [AR1,P#0.0];    //Lade aktuelles Störungs-DBD
          INVD  ;                   //Invertieren
          T     DBD [AR2,P#0.0];    //Transferiere ins Quitt-DBD
          L     DBD [AR1,P#0.0];    //Lade aktuelles Störungs-DBD
          L     L#0;                //Lade 0
          <>D   ;                   //wenn ungleich 
          S     #Stoerung;          //Setze Störung
          +AR1  P#4.0;              //Störungs-DBD um 4 Byte erhöhen
          +AR2  P#4.0;              //Quitt-DBD um 4 Byte erhöhen
          L     #Schleifenzaehler;  //Schleife fertig ?
          LOOP  GO1; 
          UN    #Word_vorhanden;    //Wenn kein Word vorhanden 
          SPB   ENDE;               //zum Ende springen 
          L     DBW [AR1,P#0.0];    //Lade aktuelles Störungs-DW
          INVI  ;                   //Invertieren
          T     DBW [AR2,P#0.0];    //Transferiere ins Quitt-DW
          L     DBW [AR1,P#0.0];    //Lade aktuelles Störungs-DW
          L     0;                  //Lade 0
          <>I   ;                   //wenn ungleich 
          S     #Stoerung;          //Setze Störung
          SPA   ENDE; 
    NETWORK
    TITLE =Störungen löschen
    QUIT: L     #Anzahl_Dword;      //Anzahl der Doppelworte
    GO2:  T     #Schleifenzaehler;  //in Schleifenzähler laden
          L     L#0;                //Lade 0
          T     DBD [AR1,P#0.0];    //Transferiere in Doppelwort 
          +AR1  P#4.0;              //Störungs-DBD um 4 Byte erhöhen
          L     #Schleifenzaehler;  //Schleife fertig ?
          LOOP  GO2; 
          SET   ; 
          R     #Stoerung;          //Störung rücksetzten
          UN    #Word_vorhanden;    //Wenn kein Word vorhanden 
          SPB   ENDE;               //zum Ende springen 
          L     0;                  //Lade 0
          T     DBW [AR1,P#0.0];    //Transferiere in Word   
    NETWORK
    TITLE =Register wiederherstellen
    ENDE: AUF   DB [#DB_Register];  //Gesicherten DB wieder öffen
          L     #AR1_Register;      //Adressregister 1 wiederherstellen 
          LAR1  ; 
          L     #AR2_Register;      //Adressregister 2 wiederherstellen
          LAR2  ; 
          SET   ;                   //VKE = 1
          SAVE  ;                   //BIE = 1
    END_FUNCTION
    Funktioniert der Code in der Praxis?


    Zur Frage:
    Wenn du dir den vom SCL-Compiler generierten Code ansiehst, solltest du die unterschiede der beiden Varianten herausfinden.

    Wieviel Zykluszeit verbrauchen denn beide Varianten?

    Habe im Moment leider kein S7 zur Hand.


    Gruß

  7. #6
    Registriert seit
    25.06.2007
    Ort
    Dresden
    Beiträge
    3.930
    Danke
    465
    Erhielt 878 Danke für 634 Beiträge

    Standard

    Zitat Zitat von epy Beitrag anzeigen
    Wow...
    Das mit der Zykluszeit mach ich morgen gleich.

    Aber wie komm ich an den AWL Code nach dem SCL Übersetzen ?

    Danke schon mal.
    Trick 15,28:

    FC75 z.B. nach FC76 kopieren (dadurch verliert der kopierte SCL Baustein die direkte SCL-kopplung) und dann öffen - wow - AWL!!!

    Frank
    Grüße Frank

  8. Folgender Benutzer sagt Danke zu IBFS für den nützlichen Beitrag:

    epy (02.09.2010)

  9. #7
    Registriert seit
    20.06.2010
    Beiträge
    170
    Danke
    14
    Erhielt 18 Danke für 12 Beiträge

    Standard

    Ich persönlich finde die Debatte SCL vs. AWL nicht sehr produktiv.
    Was soll denn dabei herauskommen?
    "Wir sind die Tollsten Programmierer?"
    Das erinnert mich einwenig daran "Ich bin der bessere Broker und schlage den DAX" (3 Wochen)
    Was ist mit mathematischen Formeln der z.B aus Physik und Verfahrenstechnik?
    Möchtest Du das auch in AWL programmieren? (z.B einen Logarythmus?)
    Oder möchest Du auch F-Systems in AWL?
    Ich habe vor 30 Jahren noch 8080 Assembler und Maschinencode programmiert und bin dankbar dass ich heute suboptimale Werkzeuge und Softwarwgeneratoren habe.

  10. #8
    Registriert seit
    13.10.2007
    Beiträge
    12.066
    Danke
    2.795
    Erhielt 3.288 Danke für 2.168 Beiträge

    Lächeln

    @JOHKU, doppelpost sind nicht produktiv, Bau mal ne
    anständige Flankenauswertung in den Antwortbutton
    - - -
    Wer als Werkzeug nur einen Hammer hat, sieht in jedem Problem einen Nagel.

  11. #9
    Registriert seit
    20.06.2010
    Beiträge
    170
    Danke
    14
    Erhielt 18 Danke für 12 Beiträge

    Standard

    Es ist mir fürchterlich peinlich aber nun mal passiert!
    Ich habe es auch sofort bemerkt aber keine Ahnung wie man einen doppelten Post dann auch löschen kann!
    Kannst DU das reparieren?(von der Reparatur)
    Gruß


  12. #10
    Registriert seit
    23.04.2009
    Ort
    Allgäu
    Beiträge
    3.042
    Danke
    241
    Erhielt 863 Danke für 617 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Das können nur die Administratoren, siehe:
    http://sps-forum.de/showthread.php?t=37144

    Entweder eine PN (persönliche Nachricht) an einen von denen, oder einfach nur den Text von deinem doppelten Beitrag löschen und etwas Kurzes rein schreiben wie:
    "Doppel Posting" oder so was in der Art.
    Schaut dann auf jeden Fall schon mal besser aus.
    Gruß
    Paule
    ----------------------------------------------------------------------------
    > manchmal verliert man und manchmal gewinnen die anderen <

Lesezeichen

Berechtigungen

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