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

Seite 1 von 5 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 46

Thema: Mittelwertbildung

  1. #1
    Registriert seit
    19.10.2007
    Beiträge
    261
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo Zusammen,
    ich habe im Forum nach einer Art Anleitung gesucht, um eine Mittelwertberechnung durchzuführen. Dabei bin ich auf Folgendes (von vierlagig!) gestoßen:

    Code:
     
    
    L 8 //Startadresse des Arrays SLD 3 //Pointererzeugen LAR1 //und ins Adressregister laden L 7 //Anzahl der Schiebevorgänge laden nex1: T #iLoopCounter L DID [AR1,P#4.0] //Startadresse + 1 DW T DID [AR1,P#0.0] //in Startadresse schreiben +AR1 P#4.0 //und das AR1 um 4.0 erhöhen = neue Startadresse L #iLoopCounter //Schleifenzähler laden LOOP nex1 //um ihn zu dekrementieren und zurückzuspringen
    L #rInput //und den aktuellen Wert T #aRealArray[7] //ins Real-ARRAY schubsen

    So, nun sind beim Durcharbeiten leider schon die ersten Fragen aufgetaucht – es wäre super, wenn ihr mir etwas helfen könntet, damit ich den Aufbau richtig verstehe…


    1) Im AR1 steht ja zu Beginn: P#8.0

    Es soll doch als erste Adresse die Anfangsadresse im Array „beschrieben“ werden – und diese erste Adresse ist doch 1 und nicht 8, oder?


    2) L DID[AR1, P#4.0] ruft ja die Startadresse + 1 Doppelwort auf.

    Warum ist es nötig, zusätzlich zur Startadresse noch ein Doppelwort zu laden?
    Zu Beginn (also beim ersten Durchlauf der Schleife) muss doch der Zeiger auf die „Ursprungsadresse“ (in diesem Fall auf Adresse 8 im Array) zeigen…

    3) „#rInput“ soll ja den aktuell anstehenden Wert, z.B. einen Messwert darstellen.

    Was aber ist beim Aufruf des Bausteins für „#aRealArray[7]“ zu übergeben?


    So, das wären zunächst einmal die ersten Fragen zu diesem Thema… wenn ich das verstanden habe, dann „forsche“ ich weiter…

    Vielen Dank schon mal bis hierhin für eure Hilfe!

    Grüße

    pinolino
    Zitieren Zitieren Mittelwertbildung  

  2. #2
    Registriert seit
    23.01.2010
    Ort
    Vechta
    Beiträge
    1
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Das Programm ist keine Mittelwertbildung, sondern ein Schieberegister.
    Der erste Wert wird gelöscht.
    Die 2. bis 8. Werte werden an Stelle 1 - 7 verschoben
    und der neue Wert (#rInput) wie an die 8. Stelle geschrieben.

    Beim Schieben müssen die Real-Werte noch addiert und durch 8 dividiert werden!
    Zitieren Zitieren Mittelwertbildung  

  3. #3
    Registriert seit
    19.06.2005
    Ort
    in Bayern ganz oben
    Beiträge
    1.360
    Danke
    188
    Erhielt 372 Danke für 290 Beiträge

    Standard

    Hallo,

    schau mal hier http://www.sps-forum.de/showpost.php...2&postcount=10

    Gruss Daniel
    Erfahrung ist eine nützliche Sache. Leider macht man sie immer erst kurz nachdem man sie brauchte...

    OSCAT.lib Step 7

    Open Source Community for Automation Technolgy

    SPS-Forum Chat (Mibbit) | SPS-Forum Chat (MIRC)

  4. #4
    pinolino ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    19.10.2007
    Beiträge
    261
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Danke für die Antworten,

    aber so ganz hab ich es noch nicht verstanden...


    Das Schieberegister soll doch acht Speicherplätze besitzen. Es werden aber nur 7 Schleifendurchläufe programmiert.

    Und warum wird als Startadresse nicht "L DID [AR1, P#0.0]" sondern "L DID [AR1, P#4.0]", also genau 1DW höher gewählt?

    Danke, pinolino

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

    Standard

    Zitat Zitat von pinolino Beitrag anzeigen
    Das Schieberegister soll doch acht Speicherplätze besitzen. Es werden aber nur 7 Schleifendurchläufe programmiert.

    Und warum wird als Startadresse nicht "
    Code:
    L DID [AR1, P#0.0
    ]" sondern "L DID [AR1, P#4.0]", also genau 1DW höher gewählt?
    Es werden 7 alte Werte verschoben, der 8.Wert ist ja der neue, der wird direkt rein geschrieben.

    L DID [AR1, P#4.0] // Der zweite Wert
    L DID [AR1, P#0.0] // wird auf den ersten geschrieben

    Nach der 1.Schleife schaut es dann so aus.
    Der Pointerversatz bleibt ja gleich aber das AR1 wird um 4 erhöht

    L DID [AR1+4, P#4.0] // Der dritte Wert
    L DID [AR1+4, P#0.0] // wird auf den zweiten geschrieben
    Gruß
    Paule
    ----------------------------------------------------------------------------
    > manchmal verliert man und manchmal gewinnen die anderen <

  6. #6
    pinolino ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    19.10.2007
    Beiträge
    261
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Zitat Zitat von Paule Beitrag anzeigen
    Es werden 7 alte Werte verschoben, der 8.Wert ist ja der neue, der wird direkt rein geschrieben.

    L DID [AR1, P#4.0] // Der zweite Wert
    L DID [AR1, P#0.0] // wird auf den ersten geschrieben

    Nach der 1.Schleife schaut es dann so aus.
    Der Pointerversatz bleibt ja gleich aber das AR1 wird um 4 erhöht

    L DID [AR1+4, P#4.0] // Der dritte Wert
    L DID [AR1+4, P#0.0] // wird auf den zweiten geschrieben
    Danke für deine Erläuterung, Paule!

    Ich nehme an in den jeweils beiden unteren Zeilen muss statt dem L ein T stehen - für Transferieren?


    Mein Problem - irgendwie komme ich mit dem Ablauf noch nicht zurecht:

    Soweit ich es verstanden habe, wird das Array von hinten nach vorne ( Platz 8 bis Platz 1) aufgefüllt.

    1) Beim ersten Durchlauf des Programms steht doch für die Anweisung ( Zeile 6 bis Zeile 8 ) noch gar kein Wert zur Verfügung. Der erste Wert wird doch erst in der letzten Anweisungszeile geladen und in das Array geschrieben.

    2) Sehe ich es richtig, dass der 8. Wert (also der jeweils neue) direkt in das 7. Feld des Arrays (T #aRealArray[7]) geschrieben wird?

    3) Ist das Array dann wie folgt deklariert:

    ARRAY [0..7] ?

    Grüße
    pinolino
    Geändert von pinolino (25.01.2010 um 12:20 Uhr)

  7. #7
    Registriert seit
    07.12.2007
    Beiträge
    49
    Danke
    5
    Erhielt 7 Danke für 7 Beiträge

    Standard

    Hier mal ein Baustein wie ich ihn verwende.

    Code:
    FUNCTION_BLOCK "FB_Mittelwertbildung"
    TITLE =Mittelwertberechnung/ Integrationsbaustein
    AUTHOR : 'F.J.'
    VERSION : 1.0
    
    
    VAR_INPUT
      Eingangswert : REAL ;    //Zu Glätender Istwert
      Speichertakt : BOOL ;    //Abfragetakt des Eingangswert
      SPS_Start : BOOL ;    //Start der Berechnung
      Zyklen : INT ;    //Ringspeichergröße (Zyklen x Speichertakt = Integrationszeit)
    END_VAR
    VAR_OUTPUT
      Zeigernummer : WORD  := W#16#10;    
      Endwert : REAL ;    //Geglaeteter Wert
    END_VAR
    VAR
      Messwert_500 : REAL ;    
      .
      .
      .
      .   
      Messwert_1 : REAL ;    
      Store_Mitteln : INT ;    
      Store_Mitteln_1 : REAL ;    
      Store_Nullen : INT ;    
      DB_wurde_Genullt : BOOL ;    
      Mittelwert : BOOL ;    
      FP_Takt : BOOL ;    
    END_VAR
    VAR_TEMP
      Impuls_Takt : BOOL ;    
      Zeiger_Speichern : DWORD ;    
      Zeiger_Mitteln : DWORD ;    
      Zeiger_Nullen : DWORD ;    
      Loops_Nullen : INT ;    
      Loops_Mitteln : INT ;    
    END_VAR
    BEGIN
    NETWORK
    TITLE =Reseten
    
          U     #SPS_Start; 
          SPB   strt; 
    
          L     0.000000e+000; 
          T     #Endwert; 
    
          L     16; 
          T     #Store_Mitteln; 
          T     #Store_Nullen; 
          T     #Zeigernummer; 
    NETWORK
    TITLE =DB Werte Nullen wenn keine abfrage
    
          U     #DB_wurde_Genullt; 
          BEB   ; 
    
          L     #Zyklen; 
    NEXT: T     #Loops_Nullen; 
          L     #Store_Nullen; 
          L     4; 
          +I    ; 
          T     #Store_Nullen; 
    
          L     #Store_Nullen; 
          SLW   3; 
          T     #Zeiger_Nullen; 
    
          L     0.000000e+000; 
          T     DID [#Zeiger_Nullen]; 
    
          L     #Loops_Nullen; 
          LOOP  NEXT; 
          S     #DB_wurde_Genullt; 
          BE    ; 
    
    strt: NOP   0; 
          R     #DB_wurde_Genullt; 
    NETWORK
    TITLE =Abtasttakt
    //im zeitintervall von x sekunden (arbeitstakt) wird ein neuer wert aufgenommen.
          U     #Speichertakt; 
          UN    #FP_Takt; 
          =     #Impuls_Takt; 
    
          U     #Speichertakt; 
          =     #FP_Takt; 
    
          U     #Impuls_Takt; 
          R     #Mittelwert; 
          SPBN  arbt; 
    NETWORK
    TITLE =Speicherzeiger prüfen wenn Speicherende erreicht
    //wenn speicherzeiger grösser als 2012 (500 Messwerte) dann auf 16 
    //setzen (zeiger für messwertNr.1) 
          L     #Zeigernummer; 
          L     4; 
          +I    ; 
          T     #Zeigernummer; 
    
          L     #Zyklen; 
          L     4; 
          *I    ; 
          L     12; 
          +I    ; 
          L     #Zeigernummer; 
          TAK   ; 
          >I    ; 
          SPBN  NULL; 
    
          L     16; 
          T     #Zeigernummer; 
    
    NULL: NOP   0; 
    
    NETWORK
    TITLE =Eingangswert abspeichern
    
          L     #Zeigernummer; 
          SLW   3; 
          T     #Zeiger_Speichern; 
          L     #Eingangswert; 
          T     DID [#Zeiger_Speichern]; 
    
    NETWORK
    TITLE =Mittelwert aus DB errechnen
    
    arbt: NOP   0; 
          U     #Mittelwert; 
          SPB   aus; 
    
          L     0.000000e+000; 
          T     #Store_Mitteln_1; 
    
          L     16; 
          T     #Store_Mitteln; 
    
    
          L     #Zyklen; 
    Next: T     #Loops_Mitteln; 
    
          L     #Store_Mitteln; 
          L     4; 
          +I    ; 
          T     #Store_Mitteln; 
    
          L     #Store_Mitteln; 
          SLW   3; 
          T     #Zeiger_Mitteln; 
          L     DID [#Zeiger_Mitteln]; 
          L     #Store_Mitteln_1; 
          +R    ; 
          T     #Store_Mitteln_1; 
    
          L     #Loops_Mitteln; 
          LOOP  Next; 
    
          L     #Zyklen; 
          ITD   ; 
          DTR   ; 
          L     #Store_Mitteln_1; 
          TAK   ; 
          /R    ; 
          T     #Endwert; 
    
          S     #Mittelwert; 
    aus:  NOP   0; 
          BE    ; 
    END_FUNCTION_BLOCK
    Cheers Flo
    Geändert von vecoplaner (25.01.2010 um 13:01 Uhr)

  8. #8
    pinolino ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    19.10.2007
    Beiträge
    261
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Danke vecoplaner,

    allerdings übersteigt dieser Baustein meine (derzeitigen) Kenntnisse!


    Insofern wäre ich für eine Beantwortung meiner vorhergehenden Fragen sehr dankbar:

    Mein Problem - irgendwie komme ich mit dem Ablauf noch nicht zurecht:

    Soweit ich es verstanden habe, wird das Array von hinten nach vorne ( Platz 8 bis Platz 1) aufgefüllt.

    1) Beim ersten Durchlauf des Programms steht doch für die Anweisung ( Zeile 6 bis Zeile 8 ) noch gar kein Wert zur Verfügung. Der erste Wert wird doch erst in der letzten Anweisungszeile geladen und in das Array geschrieben.

    2) Sehe ich es richtig, dass der 8. Wert (also der jeweils neue) direkt in das 7. Feld des Arrays (T #aRealArray[7]) geschrieben wird?

    3) Ist das Array wie folgt zu deklarieren:

    ARRAY [0..7] ?

    Grüße
    pinolino
    Geändert von pinolino (25.01.2010 um 13:08 Uhr)

  9. #9
    Registriert seit
    07.12.2007
    Beiträge
    49
    Danke
    5
    Erhielt 7 Danke für 7 Beiträge

    Standard

    Achso, du möchtest mit einem Array arbeiten (hab den fred wohl zu sehr
    überflogen), der von mir gepostete Baustein bearbeitet einfach einen
    Realwert, speichert ihn und berechnet danach den Mittelwert.
    Also nicht das was du benötigst.


    Gruß

  10. #10
    pinolino ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    19.10.2007
    Beiträge
    261
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Ja, genau - ich wollte mich gerne an das Beispiel aus meinem 1. Thread halten und es durcharbeiten...


    Allerdings ist mir aber der Ablauf noch immer nicht ganz klar; könnte hier bitte nochmals jemand helfen?


    Soweit ich es verstanden habe, wird das Array von hinten nach vorne ( Platz 8 bis Platz 1) aufgefüllt.

    1) Beim ersten Durchlauf des Programms steht doch für die Anweisung ( Zeile 6 bis Zeile 8 ) noch gar kein Wert zur Verfügung. Der erste Wert wird doch erst in der letzten Anweisungszeile geladen und in das Array geschrieben. Was passiert denn dann an dieser Stelle?

    2) Sehe ich es richtig, dass der 8. Wert (also der jeweils neue) direkt in das 7. Feld des Arrays (T #aRealArray[7]) geschrieben wird?

    3) Ist das Array wie folgt zu deklarieren:

    ARRAY [0..7] ?

    Grüße
    pinolino
    Geändert von pinolino (25.01.2010 um 13:44 Uhr)

Ähnliche Themen

  1. Erweiterte Mittelwertbildung
    Von Full Flavor im Forum Simatic
    Antworten: 7
    Letzter Beitrag: 18.10.2011, 22:30
  2. Mittelwertbildung aus integer
    Von daudel im Forum Simatic
    Antworten: 10
    Letzter Beitrag: 14.11.2010, 14:56
  3. Mittelwertbildung SIWAREX U
    Von petzi im Forum Simatic
    Antworten: 35
    Letzter Beitrag: 20.06.2010, 10:42
  4. Mittelwertbildung S5-95U
    Von demo im Forum Simatic
    Antworten: 13
    Letzter Beitrag: 28.08.2007, 21:10
  5. Mittelwertbildung
    Von Servomaster im Forum Simatic
    Antworten: 3
    Letzter Beitrag: 18.10.2005, 06:42

Lesezeichen

Berechtigungen

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