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

Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 15 von 15

Thema: FIFO mit S7 ????

  1. #11
    moclam ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    02.03.2010
    Beiträge
    6
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    @vierlagig

    << DAS WILLST DU NICHT WIRKLICH! >>
    Ich will es wirklich hoffe es bald tun zu können.

    <<v ... kleines v .... ist das denn wirklich SOOOOOO schwer?>>

    sorry wenn ich dein Name falsch geschriebe hab.


    <<ich hoffe für dich, dass du noch weißt was du meinst, ich kann es nicht erraten...>>

    Es muss einfach einen geschlossenen Baustein sein so dass der Anwender nicht wissen muß was drin ist(wie es programiert wurde). Was ihm interessiert ist nur die Schnittstelle(Z.B. welche DB er am Eingang anlägt).
    Du hast aber recht weil ich keins mehr brauche(Habe ja schon den Instanz ). Ich war noch bei FC da ich damit angefangen habe.

    <<schön ist bei fehlermeldungen immer zu wissen, was in der fehlermeldung drin steht. bei mir funktioniert die vergrößerung auf Array [0..31] of word ziemlich gut>>

    Leider markiert S7 nur Array [<1..32>] of <word> ROT und sagt nichts weiter dazu

    <<da ich immer noch nicht weiß, was du vorhast: lass es! ... das wArrayOfWord ist doch schon im instanzdatenbaustein drin, was willste mehr??? >>

    hat sich erledigt.

    Vielen Dank
    Zitieren Zitieren Fifo s7 ????  

  2. #12
    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 moclam Beitrag anzeigen
    Leider markiert S7 nur Array [<1..32>] of <word> ROT und sagt nichts weiter dazu
    lass die <><> weg und es geht
    [SIGNATUR]
    Ironie setzt Intelligenz beim Empfänger voraus.
    [/SIGNATUR]

  3. #13
    moclam ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    02.03.2010
    Beiträge
    6
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hallo vierlagig

    vielen vielen Dank .

    jetzt habe ich keine Fehler Meldung mehr.

    Werde jetzt es simulieren und mich nochmal melden

    Danke noch mal

    Moclam
    Zitieren Zitieren FIFO mit S7 ????  

  4. #14
    Registriert seit
    04.03.2010
    Beiträge
    44
    Danke
    7
    Erhielt 5 Danke für 5 Beiträge

    Standard

    Da du weiter oben geschrieben hast das du eher von der Hochsprachenseite kommst, dacht ich mir wär SCL vielleicht was für dich.
    SCL ist stark an Pascal angelehnt. Brauchste dann halt ein spezielles SCL Paket für Step7 bzw. wenn du Step7 Proffessional hast ist's da drin enthalten.

    Hab hier mal nen code für nen FIFO Puffer abgebildet. Der Puffer ist in diesem Beispiel 9 Einträge groß und wird mit Integern gefüllt.

    Code:
    FUNCTION_BLOCK FB211  // FB_FIFO
    //  Beschreibung: FB_FIFO
    //                In diesem Baustein wurde ein FIFO Puffer (Ring-Puffer) realisiert. 
    //                Es gibt zwei Zeiger einen Schreiben Zeiger und einen Lesen Zeiger. In den Puffer werden über diese Zeiger die Daten geschrieben und gelesen.
    //                Der Puffer kann bei Bedarf neu initialisiert (gelöscht) werden. Mit dem Fuellen Eingang kann der Puffer zum testen mit vorbelegten
    //                Standardwerten gefüllt werden.
    //                Schreiben hat in der Regel Vorrang vorm Lesen, das heißt steht z.B Schreiben und Lesen im gleichen Zyklus an, wird zuerst geschrieben und 
    //                anschließend gelesen. Ist der Puffer jetzt allerdings voll, würde es durch diese Vorgehensweise ja zu einem Überlauf kommen, daher wird in diesem Fall 
    //                zuerst gelesen und anschließend geschrieben.
    //                Ansonsten hat Init Vorrang vor Schreiben und Lesen. Das heißt steht Schreiben oder Lesen und eine Initialisierung im selben Zyklus an, dann wird
    //                der Auftrag fürs Schreiben bzw. Lesen verworfen.
    //                Füllen hat wiederum Vorrang vorm Initialisieren, steht hier beides in einem Zyklus an wird der Puffer initialisiert und anschließend gefüllt.
    //  Ersteller:    Didaddy
    //  Erstelldatum: 21.01.2010    
    //  Änderungen:    
    AUTHOR:   Didaddy;
    Version:  '1.0';
    
    VAR_INPUT
      nIn               :INT:= 0;                       // Der Wert der in den Puffer geschrieben werden soll
      bSchreiben        :BOOL:= FALSE;                  // Wert in Puffer schreiben (Bei Dauersignal wird der Auftrag nur einmalig ausgeführt (pos.Fl))
      bLesen            :BOOL:= FALSE;                  // Wert aus Puffer lesen (Bei Dauersignal wird der Auftrag nur einmalig ausgeführt (pos.Fl))
      bInit             :BOOL:= FALSE;                  // Puffer neu Initialisieren
      bFuellen          :BOOL:= FALSE;                  // Puffer mit Standardwerten füllen      
    END_VAR
    
    VAR_OUTPUT
      nOut              :INT:= 0;                       // Der Wert der aus dem Puffer ausgelesen werden soll
      nZS               :INT:= 1;                       // Zeiger Schreiben    
      nZL               :INT:= 1;                       // Zeiger Lesen
      nAnzVorhDaten     :INT:= 0;                       // Anzahl der vorhandenen Daten im Puffer
      bUeberlauf        :BOOL:= 0;                      // Der älteste Daten Eintrag wurde durch einen neuen überschrieben
    END_VAR
    
    CONST
      PG                := 9;                           // Puffergrenze
    END_CONST
      
    VAR
      bSchreibenAlt     :BOOL:= FALSE;
      bLesenAlt         :BOOL:= FALSE;  
      bInPufferSchreiben:BOOL:= FALSE;  
      bAusPufferLesen   :BOOL:= FALSE;
      bPufferInit       :BOOL:= FALSE; 
      bPufferFuellen    :BOOL:= FALSE;
      nI                :INT:= 0;  
      bVorrangLesen     :BOOL:= FALSE;                  // Das Lesen aus dem Puffer hat Vorrang
      anPuffer          :ARRAY[1..PG] OF INT:= [PG(0)]; 
    END_VAR
    
    LABEL
      Schreiben, Lesen;
    END_LABEL
    
    (******************** Kommandos entgegennehmen **********************)
    // Kommando in Puffer schreiben
    IF bSchreiben AND NOT bSchreibenAlt THEN
      bInPufferSchreiben:= TRUE;
    END_IF;        
    bSchreibenAlt:= bSchreiben;
    
    // Kommando aus Puffer Lesen
    IF bLesen AND NOT bLesenAlt THEN
      bAusPufferLesen:= TRUE;
    END_IF;        
    bLesenAlt:= bLesen;
    
    // Kommando Puffer Initialisieren
    IF bInit THEN
      bInPufferSchreiben:= FALSE;         // Gleichzeitig in Puffer schreiben wird ignoriert
      bAusPufferLesen:= FALSE;            // Gleichzeitig aus Puffer lesen wird ignoriert
      bPufferInit:= TRUE;
    END_IF;
    
    // Kommando Puffer fuellen
    IF bFuellen THEN
      bInPufferSchreiben:= FALSE;         // Gleichzeitig in Puffer schreiben wird ignoriert
      bAusPufferLesen:= FALSE;            // Gleichzeitig aus Puffer lesen wird ignoriert
      bPufferFuellen:= TRUE;  
    END_IF;
    
    (********** Puffer Initialisieren/Füllen, Überlauf checken **********)
    // Puffer Initialisieren
    IF bPufferInit THEN
      FOR nI := 1 TO PG BY 1 DO
        anPuffer[nI]:= 0;    
      END_FOR;
      nAnzVorhDaten:= 0;  
      nZS:= 1;
      nZL:= 1;  
      bUeberlauf:= FALSE;
      bPufferInit:= FALSE;
    END_IF;    
    
    // Puffer füllen
    IF bPufferFuellen THEN
      FOR nI := 1 TO PG BY 1 DO
        anPuffer[nI]:= nI;    
      END_FOR;
      nAnzVorhDaten:= PG;  
      nZS:= 1;
      nZL:= 1;    
      bUeberlauf:= FALSE;
      bPufferFuellen:= FALSE;
    END_IF;  
    
    // Schreiben Zeiger hat Ringgrenze erreicht    
    IF nZS > PG THEN
      nZS:= 1;
    END_IF;
    
    // Lesen Zeiger hat Ringgrenze erreicht
    IF nZL > PG THEN
      nZL := 1;
    END_IF;
    
    // Anzahl vorhandene Daten eingrenzen
    IF nAnzVorhDaten > PG THEN
      nAnzVorhDaten:= PG;
    ELSIF nAnzVorhDaten < 0 THEN
      nAnzVorhDaten:= 0;
    END_IF;       
    
    // Erkennung ob der Puffer voll ist und Lesen und Schreiben gleichzeitig ansteht
    IF nAnzVorhDaten = PG AND bInPufferSchreiben AND bAusPufferLesen THEN
      GOTO Lesen;
      bVorrangLesen:= TRUE;      // dann muss erst gelesen und anschließend geschrieben werden (wegen unnötigem Überlauf)
    ELSE
      bVorrangLesen:= FALSE;  
    END_IF;    
    
    (********************* In den Puffer schreiben **********************)
    Schreiben:
      // Wert in Puffer schreiben
      IF bInPufferSchreiben THEN
        // Überlauf checken
        IF nAnzVorhDaten = PG THEN
          bUeberlauf:= TRUE;      // Überlauf wird lediglich signalisiert, neue Daten werden natürlich trozdem eingetragen
          nZL:= nZL + 1;          // Der Lesen Zeiger wird auf den nächsten gültigen Eintrag gesetzt
        ELSE
          bUeberlauf:= FALSE;
        END_IF;
        anPuffer[nZS]:= nIn;
        nZS:= nZS + 1;
        // Nur erhöhen wenn die Puffergrenze noch nicht erreicht ist (mehr passt ja nicht rein)  
        IF nAnzVorhDaten < PG THEN 
          nAnzVorhDaten:= nAnzVorhDaten + 1; 
        END_IF;  
        bInPufferSchreiben:= FALSE;
      END_IF;
    
      // Wenn Lesen Vorrang hatte dann wurde dies ja bereits erledigt
      IF bVorrangLesen THEN
        RETURN;       // also Ende hier
      END_IF;    
    
    (*********************** Aus dem Puffer lesen ***********************)
    Lesen:
      // Nur wenn Daten vorhanden sind, können Werte ausgelesen werden
      IF nAnzVorhDaten > 0 AND bAusPufferLesen THEN
        bUeberlauf:= FALSE;         // Sobald Daten wieder ausgelesen werden, bügeln wir das Überlaufbit wieder nieder
        nOut:= anPuffer[nZL];
        anPuffer[nZL]:= 0;          // Nachdem wir den Puffer ausgelesen haben, schreiben wir ne 0 rein 
        nZL:= nZL + 1;  
        nAnzVorhDaten:= nAnzVorhDaten - 1;  
        bAusPufferLesen:= FALSE;
      ELSIF nAnzVorhDaten = 0 AND bAusPufferLesen THEN    // Sind keine Daten vorhanden
        // nichts machen  
        bAusPufferLesen:= FALSE;
      END_IF;
      
      // Wenn Lesen Vorrang hatte  
      IF bVorrangLesen THEN
        GOTO Schreiben;             // dann muß ja noch geschrieben werden
      END_IF;    
    
    END_FUNCTION_BLOCK
    Gruß Didaddy
    Zitieren Zitieren FIFO Puffer in SCL  

  5. Folgender Benutzer sagt Danke zu Didaddy für den nützlichen Beitrag:

    little01people (08.03.2017)

  6. #15
    Registriert seit
    31.07.2013
    Beiträge
    10
    Danke
    5
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Schau dir mal den FC 85 an vllt hilft dir das auch weiter

    grüße
    ohmbe

Ähnliche Themen

  1. FIFO für Staustrecke
    Von element. im Forum Simatic
    Antworten: 12
    Letzter Beitrag: 20.04.2010, 09:22
  2. Fifo Bit
    Von Jordy im Forum Simatic
    Antworten: 28
    Letzter Beitrag: 28.06.2008, 22:11
  3. Fifo S7
    Von stevexxx im Forum Simatic
    Antworten: 7
    Letzter Beitrag: 18.03.2008, 14:45
  4. Scl-fifo
    Von johnij im Forum Simatic
    Antworten: 5
    Letzter Beitrag: 12.11.2007, 08:16
  5. Fifo
    Von sweber im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 14.06.2007, 15:06

Lesezeichen

Berechtigungen

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