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

Ergebnis 1 bis 8 von 8

Thema: Zeitliche Überwachung von Analogwerten in SCL

  1. #1
    Registriert seit
    04.11.2009
    Beiträge
    3
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hi Leute,

    ich möchte folgendes in SCL machen.
    Ein Analogwert soll über eine bestimmte Zeit (40ms) überwacht werden. Wenn sich der Wert in dieser Zeit mehr als 100 Einheiten (z.B. mbar) ändert, und das zweimal hintereinander, soll er den ausgang auf eins setzen. Andernfalls soll der Ausgang auf null gesetzt werden.

    Intervall1 40ms: deltaP>100mbar
    Intervall2 40ms: deltaP>100mbar => ausgang:=1

    Intervall1 40ms: deltaP>100mbar
    Intervall1 40ms: deltaP<=100mbar => ausgang:=0

    Ich hab mir die Hilfen für Zeitfunktionen alle durchgelesen, im Internet gegoogelt. Aber nichts passendes gefunden. Zeitfunktionen kann ich nicht in While oder For Schleifen einbinden, oder geht das?
    Das Hauptproblem ist, dass er einmal den Wert einliest, sich merkt und 40ms wieder einliest und die Differenz berechnet. Hat jemand eine Idee?
    Danke im Vorraus.
    Zitieren Zitieren Zeitliche Überwachung von Analogwerten in SCL  

  2. #2
    Registriert seit
    08.08.2007
    Ort
    Dresden
    Beiträge
    9.648
    Danke
    1.059
    Erhielt 2.046 Danke für 1.627 Beiträge

    Standard

    erste idee: du brauchst nen OB35 (oder gleichwertig, falls verfügbar)
    zweite idee: du nimmst nen FB
    dritte idee: du speicherst im FB und vergleichst da ...

    in AWL könnte das so aussehen:

    Code:
    *
    FUNCTION_BLOCK FB 10
    TITLE =alt/neuwert-vergleich
    //baustein zum vergleichen eines REAL-wertes
    //
    //DATE:     17.06.2008
    //AUTHOR:   4lagig
    //VERSION:  V0.2 BasicVer
    AUTHOR : '4lagig'
    FAMILY : RealGF
    VERSION : 0.2
    
    VAR_INPUT
      rValue : REAL ;	//Wert
      rDeltaPlus : REAL ;	
      rDeltaMinus : REAL ;	
    END_VAR
    VAR_OUTPUT
      xActEquOld : BOOL ;	//neuer Wert == alter Wert
      xActBiggerOld : BOOL ;	//neuer Wert > alter Wert
      xActLowerOld : BOOL ;	//neuer Wert < alter Wert
      rValueActOut : REAL ;	
      rValueOldOut : REAL ;	
    END_VAR
    VAR
      rValueAct : REAL ;	
      rValueOld : REAL ;	
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    
    	  CLR;
    	  =     #xActEquOld;
    	  =     #xActBiggerOld;
    	  =     #xActLowerOld;
    
          L     #rValueAct; //letzten aktuellen wert
          T     #rValueOld; //in den speicherplatz alter wert
          L     #rValue; //aktuellen wert
          T     #rValueAct; //in den speicherplatz des aktuellen werts
    
          L     #rValueAct; //aktueller wert
          L     #rValueOld; //alter wert
          ==R   ; //gleich?
          SPBN  noeq; 
          =     #xActEquOld; //gleich-bit schreiben
    
    noeq: L     #rValueAct; //aktueller wert
          L     #rDeltaPlus; 
          -R    ; 
          L     #rValueOld; //alter wert
          >R    ; //größer?
          SPBN  nobi; 
          =     #xActBiggerOld; //größer-bit schreiben
    
    nobi: L     #rValueAct; //aktueller wert
          L     #rDeltaMinus; 
          +R    ; 
          L     #rValueOld; //alter wert
          <R    ; //kleiner
          SPBN  end; 
          =     #xActLowerOld; //kleiner-bit schreiben
    
    end:  L     #rValueAct; //und die werte noch
          T     #rValueActOut; //nach außen schreiben
    
          L     #rValueOld; //wenn das wirklich
          T     #rValueOldOut; //notwendig sein sollte
    
          SET   ; //und den baustein
          SAVE  ; //geordnet verlassen
    
    END_FUNCTION_BLOCK
    ich würde es auch in AWL belassen, aber der vollständigkeithalber in SCL:

    Code:
    *
    FUNCTION_BLOCK FB11
    
    VAR_INPUT
      rValue : REAL ;    //Wert
      rDeltaPlus : REAL ;    
      rDeltaMinus : REAL ;    
    END_VAR
    VAR_OUTPUT
      xActEquOld : BOOL ;    //neuer Wert == alter Wert
      xActBiggerOld : BOOL ;    //neuer Wert > alter Wert
      xActLowerOld : BOOL ;    //neuer Wert < alter Wert
      rValueActOut : REAL ;    
      rValueOldOut : REAL ;    
    END_VAR
    VAR
      rValueAct : REAL ;    
      rValueOld : REAL ;    
    END_VAR
    
        xActEquOld := false;
        xactbiggerold := false;
        xactlowerold := false;
    
        rValueOld := rValueAct;
        rValueAct := rValue;
            
        IF (rValueAct = rValueOld) THEN
            xActEquOld := true;
        END_IF;
        
        IF (rValueAct - rDeltaPlus  > rValueOld ) THEN
            xActBiggerOld := true;
        END_IF;
        
        IF (rValueAct + rDeltaMinus  < rValueOld ) THEN
            xActLowerOld := true;
        END_IF   ; 
        
        rValueActOut := rValueAct;    
        rValueOldOut := rValueOld;  
        
    END_FUNCTION_BLOCK
    ... ui ... ich bin überrascht, der AWL-code dieser Quelle ähnelt doch sehr dem handgestrickten

    Code:
    *
          SET   
          SAVE  
          =     L      0.1
          CLR   
          =     #xActEquOld
          =     #xActBiggerOld
          =     #xActLowerOld
          L     #rValueAct
          T     #rValueOld
          L     #rValue
          T     #rValueAct
          L     #rValueAct
          L     #rValueOld
          ==R   
          SPBN  A7d0
          SET   
          =     #xActEquOld
    A7d0: L     #rValueAct
          L     #rDeltaPlus
          -R    
          L     #rValueOld
          >R    
          SPBN  A7d1
          SET   
          =     #xActBiggerOld
    A7d1: L     #rValueAct
          L     #rDeltaMinus
          +R    
          L     #rValueOld
          <R    
          SPBN  A7d2
          SET   
          =     #xActLowerOld
    A7d2: L     #rValueAct
          T     #rValueActOut
          L     #rValueOld
          T     #rValueOldOut
          CLR   
          U     L      0.1
          SAVE  
          BE
    Geändert von vierlagig (05.11.2009 um 01:05 Uhr)
    [SIGNATUR]
    Ironie setzt Intelligenz beim Empfänger voraus.
    [/SIGNATUR]

  3. #3
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.788
    Danke
    398
    Erhielt 2.414 Danke für 2.010 Beiträge

    Standard

    @4L:
    wenn du die Vergleicher etwas änderst dann wird es wahrscheinlich deinem AWL-Code noch etwas ähnlicher ...
    Code:
        xActEquOld :=  (rValueAct = rValueOld) ;
        
        xActBiggerOld := (rValueAct - rDeltaPlus  > rValueOld ) ;
        
        xActLowerOld := (rValueAct + rDeltaMinus  < rValueOld ) ; 
        
        rValueActOut := rValueAct ;    
        rValueOldOut := rValueOld ;
    Gruß
    LL

  4. #4
    niceguy ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    04.11.2009
    Beiträge
    3
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    @4L
    Danke, ich verstehe aber nicht wie man das mit den 40ms machen kann.
    Dass er einmal den Wert einliest und nach 40ms nochmal und daraus die Differenz bildet..

  5. #5
    Registriert seit
    12.02.2008
    Ort
    Westfalen (Dort wo's Schwarzbrot gibt)
    Beiträge
    417
    Danke
    8
    Erhielt 87 Danke für 72 Beiträge

    Standard

    Du musst den FB alle 40ms aufrufen, wenn Du ihn ohne Änderung übernehmen willst.
    Also entweder in einem Zeit OB aufrufen oder ihn mit einem Timer alle 40ms aufrufen.

  6. #6
    Registriert seit
    08.08.2007
    Ort
    Dresden
    Beiträge
    9.648
    Danke
    1.059
    Erhielt 2.046 Danke für 1.627 Beiträge

    Standard

    Zitat Zitat von Larry Laffer Beitrag anzeigen
    @4L:
    wenn du die Vergleicher etwas änderst dann wird es wahrscheinlich deinem AWL-Code noch etwas ähnlicher ...
    LL
    och menno ... ich tu so selten in SCL proggen ... und echt zu selten auf bits verknüpfen ... *notier* *abheft* Danke!

    @niceguy
    deswegen die erste idee! timer würd ich nicht machen - zykluszeitschwankungen etc ... nicht so ideal ... OB35 alle 40ms und gut ist
    [SIGNATUR]
    Ironie setzt Intelligenz beim Empfänger voraus.
    [/SIGNATUR]

  7. #7
    niceguy ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    04.11.2009
    Beiträge
    3
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    danke jungs, habe es mit ganz vielen if anweisungen gemacht und einem 10ms ob.
    leider hab ich das von euch nicht ganz verstanden und deswegen nicht ausprobiert.

  8. #8
    Registriert seit
    08.08.2007
    Ort
    Dresden
    Beiträge
    9.648
    Danke
    1.059
    Erhielt 2.046 Danke für 1.627 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von niceguy Beitrag anzeigen
    leider hab ich das von euch nicht ganz verstanden und deswegen nicht ausprobiert.
    ja, dafür sind wir da
    [SIGNATUR]
    Ironie setzt Intelligenz beim Empfänger voraus.
    [/SIGNATUR]

Ähnliche Themen

  1. Hilfe zu Analogwerten
    Von 817Christoph im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 26.05.2010, 12:51
  2. Anfragen in eine zeitliche Reihenfolge bringen.
    Von Binaryboy im Forum Programmierstrategien
    Antworten: 10
    Letzter Beitrag: 30.08.2009, 21:12
  3. DB mit Analogwerten
    Von ziege8 im Forum Simatic
    Antworten: 9
    Letzter Beitrag: 02.04.2009, 07:36
  4. Programmierung von Analogwerten
    Von Andi_W im Forum Simatic
    Antworten: 15
    Letzter Beitrag: 04.04.2008, 20:43
  5. Scalieren von Analogwerten
    Von A.Ott im Forum Simatic
    Antworten: 18
    Letzter Beitrag: 22.02.2007, 10:53

Lesezeichen

Berechtigungen

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