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

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 12

Thema: SCL Problem (Anfänger)

  1. #1
    Registriert seit
    04.11.2013
    Beiträge
    10
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo zusammen,

    ich bin neu hier im Forum und habe ein Problem mit einem SCL-Baustein. Ich arbeite mit dem Simatic Manager V5.4.
    Ich arbeite an der Automatisierung meines Hauses und konkret an einem FB für die Rollladensteuerung.
    Der Besagte FB (siehe Anhang) soll die aktuelle Position des Rollladens selbständig berechnen. Mein Konzept ist (ähnlich wie OSCAT) so aufgebaut das an einem FB ein Eingangssignal wie z.B. I_Close nur für einen Zyklus anliegen darf, dies wird aber von den vorgeschalteten, sich bereits länger im Einsatz befindlichen FBs, sichergestellt.
    Soweit sieht das mit meinem FB auch ganz gut aus nur wenn ich die Bewegung stoppe, egal ob durch Erreichen der Zielposition oder externes Stop (I_Stop oder neuer Move Befehl)). Fängt er an die Bewegung umzukehren und fährt wieder hoch!
    Ich habe das schon etliche Male durchgespielt I_Close (fährt runter) ... warten ... I_Stop. Jetzt beginnt der Baustein den Q_Up zu schalten und berechnet auch die Rückfahrt wieder.
    Ich habe das ganze schon dutzende Male im Kopf durchgespielt komme aber nicht auf den Fehler und kann mir nicht erklären warum er plötzlich den Q_Up schaltet.
    Bin für jeden Tipp dankbar der mir hilft das Problem ggf. weiter einzugrenzen, da ich keinen Ansatz mehr habe.

    Dies ist mein allererstes SCL Programm, daher bin ich generell für alle Tipps dankbar, was sollte ich lassen, was evtl. besser / eleganter machen.

    Schöne Grüße
    chomp
    Angehängte Dateien Angehängte Dateien
    Zitieren Zitieren SCL Problem (Anfänger)  

  2. #2
    chomp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    04.11.2013
    Beiträge
    10
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hier noch der Code:
    Code:
    FUNCTION_BLOCK Blind
    
    VAR_INPUT
      I_Open: BOOL;
      I_Close: BOOL;
      I_Stop: BOOL;    
      I_TriTrig: BOOL;
      I_MoveUp: BOOL;
      I_MoveDown: BOOL;
      I_Reference: BOOL;
      I_Value: REAL;
      I_PosUp : REAL := 0.0;
      I_PosDown: REAL := 100.0;
      I_TimeUp: TIME := T#90s;
      I_TimeDown: TIME := T#90s;
    END_VAR
    
    VAR_OUTPUT
      Q_Up : BOOL;
      Q_Down : BOOL;
      Q_Moving : BOOL;
      Q_Reference : BOOL;
      Q_Position : REAL;
      Q_TimeToDest:TIME;
    END_VAR
    
    VAR_TEMP
      T_IsMovingCmd : BOOL;
      T_Stop : BOOL;
      T_LockElapsed : BOOL;
      T_CurValue : REAL;
      T_Moved : TIME;
      T_CalcBaseTime : TIME;
    END_VAR
    
    CONST
        OFFSET_TIME := T#1S;
        ZERO_T := T#0S;
        LOCK_TIME := T#50Ms;
        UP := 0;
        DOWN := 1;
    END_CONST
    
    VAR
      IsReference : BOOL := false;
      ReferenceDone : BOOL := false;
      LastDirection : INT := UP;
      StartValue : REAL := 0.0; 
      GivenValue : REAL := 0.0;
      TimeStart : TIME := ZERO_T; 
      TimeToMove : TIME := ZERO_T;
      StartLock : TIME := ZERO_T;
    END_VAR
    
    
    
    LABEL
        M1, End;
    END_LABEL
    
    
    BEGIN
    
    //init Temp vars
    T_Stop := false;
    T_CurValue := Q_Position;
    T_CalcBaseTime := ZERO_T;
    T_Moved := ZERO_T;
    T_LockElapsed := false;
    T_IsMovingCmd := (  I_Open OR  I_Close OR I_TriTrig OR I_MoveUp OR I_MoveDown OR I_Reference);
    
    //check lock
    IF NOT(StartLock = ZERO_T) THEN;
        IsTimeElapsed(T_Start :=  StartLock
                      ,T_Time2Go :=  LOCK_TIME
                      ,Q := T_LockElapsed
                      );
      
      IF(T_LockElapsed) 
          THEN StartLock := ZERO_T;
          ELSE GOTO End;
      END_IF;
    END_IF;
    
    // Stop on new Command 
    IF(T_IsMovingCmd AND Q_Moving) THEN;
        T_Stop := true;
        GOTO M1;
    END_IF;
    
    IF I_Open THEN;
       Q_Up := true;
       Q_Down := false;
       GivenValue := I_PosUp;
       StartValue := Q_Position;
       TimeToMove := DINT_TO_TIME(REAL_TO_DINT( (Q_Position * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 )) + OFFSET_TIME;
       TimeStart:= TIME_TCK();
            
    ELSIF I_Close THEN;
       Q_Up := false; 
       Q_Down := true;
       GivenValue := I_PosDown;
       StartValue := Q_Position;
       TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((100.0 - Q_Position) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown))  ) / 100)) + OFFSET_TIME;
       TimeStart:= TIME_TCK();
            
    ELSIF I_TriTrig THEN;
        IF( LastDirection = UP) THEN;
             Q_Up := false; 
             Q_Down := true;
             GivenValue := I_PosDown;
             StartValue := Q_Position;
             TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((100.0 - Q_Position) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown))  ) / 100)) + OFFSET_TIME;
             TimeStart:= TIME_TCK();
        ELSIF (LastDirection = DOWN) THEN;
             Q_Up := true;
             Q_Down := false;
             GivenValue := I_PosUp;
             StartValue := Q_Position;
             TimeToMove := DINT_TO_TIME(REAL_TO_DINT( (Q_Position * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 )) + OFFSET_TIME;
             TimeStart:= TIME_TCK();
        END_IF;
               
            
    ELSIF I_MoveUp THEN;
       IF NOT(TimeStart = ZERO_T) THEN;
          Q_Up := true;
          Q_Down := false;
          TimeStart := TIME_TCK();
          StartValue := Q_Position;
          TimeToMove := ZERO_T;
       END_IF;
              
    ELSIF I_MoveDown THEN;
       IF NOT(TimeStart = ZERO_T) THEN;
          Q_Up := false;
          Q_Down := true;
          TimeStart := TIME_TCK();
          StartValue := Q_Position;
          TimeToMove := ZERO_T;
       END_IF;
            
    ELSIF I_Stop THEN;
          T_Stop := true;
        
    ELSIF I_Reference THEN;
        Q_Up := true; 
        Q_Down := false;
        GivenValue := I_PosDown;
        StartValue := Q_Position;
        TimeToMove := I_TimeUp + OFFSET_TIME;
        TimeStart:= TIME_TCK();
        IsReference := true;
    
    ELSIF NOT(I_Value = GivenValue) THEN;
        IF NOT (Q_Moving) THEN;
            StartValue := Q_Position;
            GivenValue := I_Value;
            TimeStart := TIME_TCK();
            IF (GivenValue > Q_Position) THEN;
                Q_Up := false;
                Q_Down := true;
                TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((100.0 - (GivenValue - Q_Position)) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown)) ) / 100));
            ELSE;
                Q_Up := true;
                Q_Down := false;
                TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((Q_Position - GivenValue) * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 ));
            END_IF;
        END_IF;
    
    ELSIF (IsReference AND ReferenceDone) THEN;
        IsReference := false;
        GivenValue := StartValue;
        StartValue := Q_Position;
        TimeStart := TIME_TCK();
        IF (GivenValue > Q_Position) THEN;
            Q_Up := false;
            Q_Down := true;
            TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((100.0 - (GivenValue - Q_Position)) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown)) ) / 100));
        ELSE;
            Q_Up := true;
            Q_Down := false;
            TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((Q_Position - GivenValue) * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 ));
        END_IF;
    
    
        
    ELSIF NOT(Q_Moving) THEN;
        //Nothing todo;
        RETURN;
        
    END_IF;
    
    // ----- End Of Inputanalysis --------------------------------------------------//
    
    M1: ;
    
    //Calculate Position on Moving
    IF(Q_Moving) THEN;
        T_Moved := (TIME_TCK() - TimeStart);
        
        IF(TimeToMove > ZERO_T) THEN;    
            T_CalcBaseTime := TimeToMove;
        ELSIF (Q_Moving) THEN;
            TimeToMove := T_Moved;
            IF (I_MoveUp) THEN;
                T_CalcBaseTime := I_TimeUp;
            ELSIF(I_MoveDown) THEN;
                T_CalcBaseTime := I_TimeDown;
            END_IF;    
        END_IF;
        
        T_CurValue := 100 * (DINT_TO_REAL(TIME_TO_DINT(T_Moved)) / DINT_TO_REAL(TIME_TO_DINT(T_CalcBaseTime))); 
        
        IF Q_Up THEN 
            T_CurValue := (StartValue - T_CurValue);
        ELSE;
            T_CurValue := (StartValue + T_CurValue);
        END_IF;
            
        IF(T_Moved >= TimeToMove) THEN;
            T_Stop := true;
        END_IF;
    END_IF;
    
    
    IF(T_Stop) THEN;
        IF(Q_Up) THEN;
            LastDirection := UP;
        ELSE;
            LastDirection := DOWN;
        END_IF;
            
        Q_Up := false;
        Q_Down := false;
        T_Moved := ZERO_T;
        TimeToMove := ZERO_T;
        TimeStart := ZERO_T;
        StartLock := TIME_TCK();
        
        IF(IsReference) THEN;
            ReferenceDone := true;
        END_IF;
    END_IF;
      
    IF(T_CurValue <= 0) THEN;
        Q_Position := 0.0;
    ELSIF(T_CurValue > 100) THEN;
        Q_Position := 100.0;
    ELSE;
        Q_Position := T_CurValue;
    END_IF;
    
    Q_Moving := (Q_Up OR Q_Down);
    Q_TimeToDest := (TimeToMove - T_Moved);
    
    
    END: ; //Function End
    
    END_FUNCTION_BLOCK
    Edit: Was mir auch nicht gefällt sind die Codedoppelungen. In c würde ich hier eine Funktion schreiben, aber in SCL habe ich leider keine Idee


    Schöne Grüße
    chomp
    Geändert von chomp (04.11.2013 um 21:08 Uhr) Grund: Ergänzung
    Zitieren Zitieren SCL Problem (Anfänger)  

  3. #3
    chomp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    04.11.2013
    Beiträge
    10
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Ok, nach noch mehr Durchläufen und Gehirnschmalz gelöst! Der Vollständigkeit halber:

    Code:
    FUNCTION_BLOCK Blind
    
    VAR_INPUT
      I_Open: BOOL;
      I_Close: BOOL;
      I_Stop: BOOL;
      I_TriTrig: BOOL;
      I_MoveUp: BOOL;
      I_MoveDown: BOOL;
      I_Reference: BOOL;
      I_Value: REAL;
      I_PosUp : REAL := 0.0;
      I_PosDown: REAL := 100.0;
      I_TimeUp: TIME := T#90s;
      I_TimeDown: TIME := T#90s;
    END_VAR
    
    VAR_OUTPUT
      Q_Up : BOOL;
      Q_Down : BOOL;
      Q_Moving : BOOL;
      Q_Reference : BOOL;
      Q_Position : REAL;
      Q_TimeToDest:TIME;
    END_VAR
    
    VAR_TEMP
      T_IsMovingCmd : BOOL;
      T_Stop : BOOL;
      T_LockElapsed : BOOL;
      T_CurValue : REAL;
      T_Moved : TIME;
      T_CalcBaseTime : TIME;
    END_VAR
    
    CONST
        OFFSET_TIME := T#1S;
        ZERO_T := T#0S;
        LOCK_TIME := T#50Ms;
        UP := 0;
        DOWN := 1;
    END_CONST
    
    VAR
      IsReference : BOOL := false;
      ReferenceDone : BOOL := false;
      LastDirection : INT := UP;
      StartValue : REAL := 0.0;
      GivenValue : REAL := 0.0;
      TimeStart : TIME := ZERO_T;
      TimeToMove : TIME := ZERO_T;
      StartLock : TIME := ZERO_T;
    END_VAR
    
    LABEL
        M1, End;
    END_LABEL
    
    
    BEGIN
    
    //init Temp vars
    T_Stop := false;
    T_CurValue := Q_Position;
    T_CalcBaseTime := ZERO_T;
    T_Moved := ZERO_T;
    T_LockElapsed := false;
    T_IsMovingCmd := (  I_Open OR  I_Close OR I_TriTrig OR I_MoveUp OR I_MoveDown OR I_Reference);
    
    //check lock
    IF NOT(StartLock = ZERO_T) THEN;
        IsTimeElapsed(T_Start :=  StartLock
                      ,T_Time2Go :=  LOCK_TIME
                      ,Q := T_LockElapsed
                      );
    
      IF(T_LockElapsed)
          THEN StartLock := ZERO_T;
          ELSE GOTO End;
      END_IF;
    END_IF;
    
    // Stop on new Command
    IF(T_IsMovingCmd AND Q_Moving) THEN;
        T_Stop := true;
        GOTO M1;
    END_IF;
    
    IF I_Open THEN;
       Q_Up := true;
       Q_Down := false;
       GivenValue := I_PosUp;
       StartValue := Q_Position;
       TimeToMove := DINT_TO_TIME(REAL_TO_DINT( (Q_Position * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 )) + OFFSET_TIME;
       TimeStart:= TIME_TCK();
    
    ELSIF I_Close THEN;
       Q_Up := false;
       Q_Down := true;
       GivenValue := I_PosDown;
       StartValue := Q_Position;
       TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((100.0 - Q_Position) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown))  ) / 100)) + OFFSET_TIME;
       TimeStart:= TIME_TCK();
    
    ELSIF I_TriTrig THEN;
        IF( LastDirection = UP) THEN;
             Q_Up := false;
             Q_Down := true;
             GivenValue := I_PosDown;
             StartValue := Q_Position;
             TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((100.0 - Q_Position) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown))  ) / 100)) + OFFSET_TIME;
             TimeStart:= TIME_TCK();
        ELSIF (LastDirection = DOWN) THEN;
             Q_Up := true;
             Q_Down := false;
             GivenValue := I_PosUp;
             StartValue := Q_Position;
             TimeToMove := DINT_TO_TIME(REAL_TO_DINT( (Q_Position * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 )) + OFFSET_TIME;
             TimeStart:= TIME_TCK();
        END_IF;
    
    
    ELSIF I_MoveUp THEN;
       IF (TimeStart = ZERO_T) THEN;
          Q_Up := true;
          Q_Down := false;
          TimeStart := TIME_TCK();
          StartValue := Q_Position;
          TimeToMove := ZERO_T;
       END_IF;
    
    ELSIF I_MoveDown THEN;
       IF (TimeStart = ZERO_T) THEN;
          Q_Up := false;
          Q_Down := true;
          TimeStart := TIME_TCK();
          StartValue := Q_Position;
          TimeToMove := ZERO_T;
       END_IF;
    
    ELSIF I_Stop THEN;
          T_Stop := true;
    
    ELSIF I_Reference THEN;
        Q_Up := true;
        Q_Down := false;
        GivenValue := I_PosDown;
        StartValue := Q_Position;
        TimeToMove := I_TimeUp + OFFSET_TIME;
        TimeStart:= TIME_TCK();
        IsReference := true;
        ReferenceDone := false;
    
    ELSIF NOT(I_Value = GivenValue) THEN;
        IF NOT (Q_Moving) THEN;
            StartValue := Q_Position;
            GivenValue := I_Value;
            TimeStart := TIME_TCK();
            IF (GivenValue > Q_Position) THEN;
                Q_Up := false;
                Q_Down := true;
                TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((GivenValue - Q_Position) * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown)) ) / 100));
            ELSE;
                Q_Up := true;
                Q_Down := false;
                TimeToMove := DINT_TO_TIME(REAL_TO_DINT( ((Q_Position - GivenValue) * DINT_TO_REAL(TIME_TO_DINT(I_TimeUp))) / 100 ));
            END_IF;
        END_IF;
        
    
    ELSIF (IsReference AND ReferenceDone) THEN;
        IsReference := false;
        Q_Up := false;        
        Q_Down := true;
        GivenValue := StartValue;
        StartValue := Q_Position;
        TimeStart := TIME_TCK();
        TimeToMove := DINT_TO_TIME(REAL_TO_DINT( GivenValue * DINT_TO_REAL(TIME_TO_DINT(I_TimeDown)) ) / 100);
    
    ELSIF NOT(Q_Moving) THEN;
        //Nothing todo;
        RETURN;
    
    END_IF;
    
    // ----- End Of Inputanalysis --------------------------------------------------//
    
    M1: ;
    
    //Calculate Position on Moving
    IF(Q_Moving) THEN;
        T_Moved := (TIME_TCK() - TimeStart);
    
        IF(TimeToMove = ZERO_T) THEN;
            TimeToMove := T_Moved;
        END_IF;
    
        IF (Q_Up) THEN;
            T_CalcBaseTime := I_TimeUp;
        ELSE;
            T_CalcBaseTime := I_TimeDown;
        END_IF;
            
        T_CurValue := 100 * (DINT_TO_REAL(TIME_TO_DINT(T_Moved)) / DINT_TO_REAL(TIME_TO_DINT(T_CalcBaseTime)));
    
        IF Q_Up THEN
            T_CurValue := (StartValue - T_CurValue);
        ELSE;
            T_CurValue := (StartValue + T_CurValue);
        END_IF;
    
        IF(T_Moved > TimeToMove) THEN;
            T_Stop := true;
        END_IF;
    END_IF;
    
    
    IF(T_Stop) THEN;
        IF(Q_Up) THEN;
            LastDirection := UP;
        ELSE;
            LastDirection := DOWN;
        END_IF;
    
        Q_Up := false;
        Q_Down := false;
        T_Moved := ZERO_T;
        TimeToMove := ZERO_T;
        TimeStart := ZERO_T;
        StartLock := TIME_TCK();
        GivenValue := I_Value;
    
        IF(IsReference) THEN;
            ReferenceDone := true;
        END_IF;
    END_IF;
    
    IF(T_CurValue <= 0) THEN;
        Q_Position := 0.0;
    ELSIF(T_CurValue > 100) THEN;
        Q_Position := 100.0;
    ELSE;
        Q_Position := T_CurValue;
    END_IF;
    
    Q_Moving := (Q_Up OR Q_Down);
    Q_TimeToDest := (TimeToMove - T_Moved);
    
    
    END: ; //Function End
    
    END_FUNCTION_BLOCK
    Wobei ich immer noch die oben genannten unschönheiten im Code habe und für konstruktive Kritik dankbar bin!

    Gruß chomp
    Zitieren Zitieren Fixed  

  4. #4
    Registriert seit
    30.06.2007
    Ort
    Minden (Westf.)
    Beiträge
    178
    Danke
    42
    Erhielt 21 Danke für 21 Beiträge

    Standard

    Etwas eleganter ist es, wenn du die Abfrage mit den vielen "ELSEIF" gegen eine "CASE" Anweisung ersetzt.
    Und...
    "GOTO" geht gar nicht, kann man wesentlich eleganter mit "IF" lösen...

  5. #5
    chomp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    04.11.2013
    Beiträge
    10
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hallo StefanK,

    danke fürs Feedback. Ja das Thema mit den GOTOs, ich bin auch kein Freund davon und prinzipiell auf dem gleichen Standpunkt wie du. Allerdings gilt auch, keine Ausnahme ohne Regel. Im konkreten Fall könnte man anstelle des GOTO den unteren, ebenfalls von dir kritisierten Block, in eine ELSE Zweig packen und das GOTO wäre raus, ob es das aber so viel übersichtlicher macht stelle ich an der Stelle in Frage. In der Sacher gebe ich dir aber recht!
    Zum zweiten (ersten Teil) das CASE. Ich prüfe hier die Eingänge, sprich verschiedene Variablen, bei einem Case Bräuchte ich doch aber nur eine Variable. Oder würdest du hier alle I_xxx auf einen T_xxx mappen und dann ein
    Switch (T_xxx) ?

    Edit: Zum switch-case nochmal. In C wäre die If-Else Lösung effizienter da hier zu > 80% der I_Close und der I_Open gesetzt würden und diese ganz oben stehen.

    Schöne Grüße
    chomp
    Geändert von chomp (05.11.2013 um 08:26 Uhr)

  6. #6
    Registriert seit
    09.08.2006
    Beiträge
    3.627
    Danke
    912
    Erhielt 656 Danke für 542 Beiträge

    Standard

    Zitat Zitat von chomp Beitrag anzeigen
    In C wäre die If-Else Lösung effizienter da
    ...
    Was mir auch nicht gefällt sind die Codedoppelungen. In c würde ich hier eine Funktion schreiben, aber in SCL habe ich leider keine Idee
    Zum GOTO gibt's hier im Forum nen ellenlangen Thread... (ich find die GOTOs oder RETURN in nem SCL Code auch nicht so toll, aber das ist Ansichtssache)

    Effizienz ist in SPS-Programmen in aller Regel nebensächlich... Viel wichtiger ist einfach (auch von anderen Kollegen, Inbetriebnehmern, Instandhaltern, von Dir nach 5 Jahren...) zu verstehender Code... Und SCL ist nicht C... In Deinem Code fehlen mir sämtliche Kommentare!

    Ansonsten kannst Du auch in einer SPS Funktionen (FC) und Funktionsbausteine (FB) für wiederkehrende Aufgaben erstellen, und diese dann in Deinem Code aufrufen.

  7. #7
    Registriert seit
    30.06.2007
    Ort
    Minden (Westf.)
    Beiträge
    178
    Danke
    42
    Erhielt 21 Danke für 21 Beiträge

    Standard

    Zitat Zitat von chomp Beitrag anzeigen
    Hallo StefanK,

    Zum zweiten (ersten Teil) das CASE. Ich prüfe hier die Eingänge, sprich verschiedene Variablen, bei einem Case Bräuchte ich doch aber nur eine Variable. Oder würdest du hier alle I_xxx auf einen T_xxx mappen und dann ein
    Switch (T_xxx) ?

    chomp
    Ich habe jetzt gerade kein Step7 zur Hand, aber in anderen Sprachen sind solche Konstrukte möglich:

    Code:
    CASE TRUE OF
    I_Open :
    ...
    I_Close :
    ...
    ...
    ELSE
    ...
    END_CASE



  8. #8
    chomp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    04.11.2013
    Beiträge
    10
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Und SCL ist nicht C...
    Natürlich nicht, so war das auch nicht gemeint. Nur war das eben meine Überlegung dazu. Das das mit der Effizenz nicht so eine Rolle spielen soll? Hm, ok in meiner kleinen Haussteuerung wohl schon, da wird sich auch meine kleine CPU langweilen, aber trifft das auch auf Industrieanlagen zu?

    Code:
    CASE TRUE OF 
       I_Open : ... 
       I_Close : ... 
       ... ELSE 
       END_CASE
    Ok, das habe ich probiert:
    "Der CASE-Ausdruck muss vom Typ INT sein." Hätte ich jetzt auch so erwartet.

    Danke für die Hinweise.

    Gruß chomp

  9. #9
    Registriert seit
    30.08.2010
    Ort
    Östereich
    Beiträge
    1.458
    Danke
    503
    Erhielt 217 Danke für 192 Beiträge

    Standard

    wenn du bei uns in der Firma aufschlagen solltest, dann vergiss alles was in SCL Programmiert wird!
    In FUP! SCL und AWL ist zwar möglich, muss aber im Einzelfall von uns freigegeben werden (also vor allem entsprechend mit vernünftigen Kommentaren versehen sein und vernünftig gekapselt sein!)
    ca., 98% lässt sich in FUP programmieren ist dann auch von 95% der Instand Halter lesbar! wenn der Rest noch entsprechend Kommentiert ist gibt es keine Probleme bei IBN und weiterhin.

    Alles in SCL und du bist von vorne heraus auf der Abschussliste!

    Warum nicht gleich in FUP?

    Warte mal auf die entsprechenden Kommentare der reinen Prog-Fraktion

    SCL ist nun mal bei den Instand haltern ein rotes Tuch!

    Abgekapselte Bausteine für Datenübertragung, Auswertung, . . . OK wenn entsprechend kommentiert -> OK
    Aber die reine Grundfunktion des Programms sollte für alle verständlich sein -> FUP (Ev KOP)

    Wer anders kommt, kann alles bei "0" beginnen!
    Geändert von winnman (06.11.2013 um 00:01 Uhr)
    Elektrotechnik und Elektronik funktioniert mit Rauch (Beweis: Tritt Rauch aus, funktioniert auch das Bauteil nicht mehr)

  10. #10
    Registriert seit
    27.06.2009
    Ort
    am Nordharz
    Beiträge
    3.717
    Danke
    443
    Erhielt 919 Danke für 740 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von winnman Beitrag anzeigen
    ca., 98% lässt sich in FUP programmieren ist dann auch von 95% der Instand Halter lesbar!
    Halte ich beides für'n Gerücht.




    Zitat Zitat von winnman Beitrag anzeigen
    SCL ist nun mal bei den Instand haltern ein rotes Tuch!
    Halte mich für einen. Doch da ich mehr im Automotiv zu Hause bin, geht's mir eher mit FUP so.
    Also ruhig mal über'n Tellerrand schauen. Nicht jede Firma ist gleichbedeutend mit dem Rest der Welt.




    Mal davon abgesehen - chomp programmiert da Rollläden. Ich denke mal, wir haben's hier mit 'nem Häuslebauer zu tun. Und wenn dem so ist, muss das Ganze hauptsächlich einer verstehen -> er selbst.




    Aber in einem muss ich Dir Recht geben:
    Zitat Zitat von winnman Beitrag anzeigen
    vor allem entsprechend mit vernünftigen Kommentaren versehen sein

Ähnliche Themen

  1. TIA Simulation SCL Anfänger benötigt Hilfe
    Von EMZ im Forum Simatic
    Antworten: 6
    Letzter Beitrag: 11.09.2013, 21:43
  2. SCL Anfänger
    Von Placidjam im Forum Simatic
    Antworten: 9
    Letzter Beitrag: 07.09.2012, 10:39
  3. S7-SCL Anfänger
    Von StepUser im Forum Simatic
    Antworten: 10
    Letzter Beitrag: 26.08.2011, 07:55
  4. Anfänger in SCL
    Von bluebird277 im Forum Simatic
    Antworten: 12
    Letzter Beitrag: 12.11.2010, 08:55
  5. SCL Anfänger sucht Hilfe!
    Von hans55 im Forum Simatic
    Antworten: 7
    Letzter Beitrag: 11.12.2007, 22:48

Stichworte

Lesezeichen

Berechtigungen

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