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

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

Thema: Ringpuffer FIFO ! ... derweil nur mit INT ( wie aber mit BOOL+INT+DINT+REAL?)

  1. #1
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Rotes Gesicht


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Code:
    FUNCTION_BLOCK "RINGPUFFER"TITLE =
    VERSION : 0.1
    
    
    
    
    VAR_INPUT
      INIT : BOOL ;    //Initialisieren
      EIN : BOOL ;    //Schreibsignal
      AUS : BOOL ;    //Lesesignal
      INPUT : INT ;    //WOHER SCHREIBEN ?
    END_VAR
    VAR_OUTPUT
      OUTPUT : WORD ;    //WOHIN  LESEN ?
    END_VAR
    VAR
      Sindex : INT ;    //Schreibindex
      Lindex : INT ;    //Leseindex
      EINflanke : BOOL ;    //Schreibsignal Flanke
      AUSflanke : BOOL ;    //Lesesignal Flanke
      INITflanke : BOOL ;    //Nullensignal Flanke
      LFM : BOOL ;    //Leseflanke Merker
      SFM : BOOL ;    //Schreibflanke Merker
      Besetzt : BOOL ;    //1=Lesen möglich
      Platz : ARRAY  [1 .. 5 ] OF INT ;    
    END_VAR
    VAR_TEMP
      tempAR1 : DWORD ;    //AR1retten
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    //EINGABE
          U     #INIT; 
          FP    #INITflanke; 
          SPB   INIT; //INITIALISIEREN
    
    
          U     #AUS; 
          FP    #AUSflanke; 
          =     #LFM; 
          SPB   AUSL; //LESEN
    
    
          U     #EIN; 
          FP    #EINflanke; 
          =     #SFM; 
          SPB   EINS; //SCHREIBEN
          BE    ; 
    NETWORK
    TITLE =
    //INITIALISIERN
    INIT: L     0; 
          T     #Lindex; 
          T     #Sindex; 
          TAR1  #tempAR1; 
          LAR1  ; 
          L     P##Platz; 
          +AR1  ; 
          TAR2  ; 
          +AR1  ; 
          L     0; 
          T     DIW [AR1,P#0.0]; 
          T     #OUTPUT; 
          LAR1  #tempAR1; //AR retten
          CLR   ; 
          =     #Besetzt; 
          BE    ; 
    NETWORK
    TITLE =
    //LESEN
    AUSL: L     #Sindex; 
          L     #Lindex; 
          <>I   ; 
          SPB   o0; 
          UN    #Besetzt; 
          SPB   o1; 
    o0:   SLD   4; 
          TAR1  #tempAR1; 
          LAR1  ; 
          L     P##Platz; 
          +AR1  ; 
          TAR2  ; 
          +AR1  ; 
          L     DIW [AR1,P#0.0]; 
          T     #OUTPUT; 
          LAR1  #tempAR1; 
          L     #Lindex; 
          L     1; 
          +I    ; 
          L     4; //5=0->4
          TAK   ; 
          >=I   ; 
          SPB   o2; 
          L     0; 
    o2:   T     #Lindex; 
          CLR   ; 
          =     #Besetzt; 
          U     #LFM; 
          U     #SFM; 
          SPB   EINS; 
          BE    ; 
    o1:   L     0; 
          T     #OUTPUT; 
          U     #LFM; 
          U     #SFM; 
          SPB   EINS; 
          BE    ; 
    NETWORK
    TITLE =
    //SCHREIBEN
    EINS: L     #Lindex; 
          L     #Sindex; 
          <>I   ; 
          SPB   oo0; 
          U     #Besetzt; 
          SPB   oo1; 
    oo0:  SLD   4; 
          TAR1  #tempAR1; 
          LAR1  ; 
          L     P##Platz; 
          +AR1  ; 
          TAR2  ; 
          +AR1  ; 
          L     #INPUT; 
          T     DIW [AR1,P#0.0]; 
          LAR1  #tempAR1; 
          L     #Sindex; 
          L     1; 
          +I    ; 
          L     4; //5=0->4
          TAK   ; 
          >=I   ; 
          SPB   oo2; 
          L     0; 
    oo2:  T     #Sindex; 
          SET   ; 
          =     #Besetzt; 
    oo1:  BE    ; 
    END_FUNCTION_BLOCK

    FIFO.zip
    Hab' eure Ratschläge mit einbezogen


    ..das ganze Programm ist nur eine Übung in AWL .Wie könnte ich diese FIFO so programmieren dass als input nicht nur INT sondern auch jeweils BOOL , DINT oder REAL speichert ? ANY als INPUT ist mir schon klar aber OUTPUT ?... den kann man nicht variabel definieren , oder ?
    Soll ich es als WORD (DWORD) nehmen den OUTPUT und über eine angehhängte FC mit MOVE "übersetzen" ?
    PS: FIFO funktioniert soweit ich es getestet habe ; FIFO-grösse kann man mit der ARRAY grösse ändern !

    (ÄNDERUNG: THEMA/THREAD umbenannt)
    Geändert von 00alex (29.05.2013 um 14:36 Uhr)
    Zitieren Zitieren Ringpuffer FIFO ! (INT;BOOL)  

  2. #2
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Standard

    Code:
    //EINGABE
          U     #INIT; 
          FP    #INITflanke; 
          SPB   INIT; //INITIALISIEREN
    
    
          U     #AUS; 
          FP    #AUSflanke; 
          =     #LFM; 
          U     #EIN; 
          FP    #EINflanke; 
          =     #SFM; 
    
          U     #LFM; 
          SPB   AUSL; //LESEN
    
          U     #SFM; 
          SPB   EINS; //SCHREIBEN
    
          BE    ;
    ...sorry !

  3. #3
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Frage

    FIFO-RINGPUFFER mit BOOLs , FIFO-grösse über den ARRAY änderbar !(jetzt 17=0->16)
    Code:
    FUNCTION_BLOCK "RINGPUFFER"
    TITLE =
    VERSION : 0.1
    
    
    VAR_INPUT
      INIT : BOOL ;	//Initialisieren
      EIN : BOOL ;	//Schreibsignal
      AUS : BOOL ;	//Lesesignal
      INPUT : BOOL ;	//WOHER SCHREIBEN ?
    END_VAR
    VAR_OUTPUT
      OUTPUT : BOOL ;	//WOHIN  LESEN ?
    END_VAR
    VAR
      Sindex : INT ;	//Schreibindex
      Lindex : INT ;	//Leseindex
      EINflanke : BOOL ;	//Schreibsignal Flanke
      AUSflanke : BOOL ;	//Lesesignal Flanke
      INITflanke : BOOL ;	//Nullensignal Flanke
      LFM : BOOL ;	//Leseflanke Merker
      SFM : BOOL ;	//Schreibflanke Merker
      Besetzt : BOOL ;	//1=Lesen möglich
      Platz : ARRAY  [1 .. 17 ] OF BOOL ;	
    END_VAR
    VAR_TEMP
      tempAR1 : DWORD ;	//AR1retten
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    //EINGABE
          U     #INIT; 
          FP    #INITflanke; 
          SPB   INIT; //INITIALISIEREN
    
    
          U     #AUS; 
          FP    #AUSflanke; 
          =     #LFM; 
          U     #EIN; 
          FP    #EINflanke; 
          =     #SFM; 
    
          U     #LFM; 
          SPB   AUSL; //LESEN
    
          U     #SFM; 
          SPB   EINS; //SCHREIBEN
          BE    ; 
    NETWORK
    TITLE =
    //INITIALISIERN
    INIT: L     0; 
          T     #Lindex; 
          T     #Sindex; 
          TAR1  #tempAR1; 
          LAR1  ; 
          L     P##Platz; 
          +AR1  ; 
          TAR2  ; 
          +AR1  ; 
          CLR   ; 
          =     DIX [AR1,P#0.0]; 
          =     #OUTPUT; 
          =     #Besetzt; 
          LAR1  #tempAR1; 
          BE    ; 
    NETWORK
    TITLE =
    //LESEN
    AUSL: L     #Sindex; 
          L     #Lindex; 
          <>I   ; 
          SPB   o0; 
          UN    #Besetzt; 
          SPB   o1; 
    o0:   SLD   0; 
          TAR1  #tempAR1; 
    
          L     8; 
          /I    ; 
          PUSH  ; 
          TAD   ; 
          TAW   ; 
          UW    W#16#FF; 
          LAR1  ; 
          POP   ; 
          UW    W#16#FF; 
          SLD   3; 
          +AR1  ; 
    
    
          L     P##Platz; 
          +AR1  ; 
          TAR2  ; 
          +AR1  ; 
          U     DIX [AR1,P#0.0]; 
          =     #OUTPUT; 
          LAR1  #tempAR1; 
          L     #Lindex; 
          L     1; 
          +I    ; 
          L     16; //17=0->16
          TAK   ; 
          >=I   ; 
          SPB   o2; 
          L     0; 
    o2:   T     #Lindex; 
          CLR   ; 
          =     #Besetzt; 
          U     #LFM; 
          U     #SFM; 
          SPB   EINS; 
          BE    ; 
    o1:   CLR   ; 
          =     #OUTPUT; 
          U     #LFM; 
          U     #SFM; 
          SPB   EINS; 
          BE    ; 
    NETWORK
    TITLE =
    //SCHREIBEN
    EINS: L     #Lindex; 
          L     #Sindex; 
          <>I   ; 
          SPB   oo0; 
          U     #Besetzt; 
          SPB   oo1; 
    oo0:  SLD   0; 
          TAR1  #tempAR1; 
    
          L     8; 
          /I    ; 
          PUSH  ; 
          TAD   ; 
          TAW   ; 
          UW    W#16#FF; 
          LAR1  ; 
          POP   ; 
          UW    W#16#FF; 
          SLD   3; 
          +AR1  ; 
    
          L     P##Platz; 
          +AR1  ; 
          TAR2  ; 
          +AR1  ; 
          U     #INPUT; 
          =     DIX [AR1,P#0.0]; 
          LAR1  #tempAR1; 
          L     #Sindex; 
          L     1; 
          +I    ; 
          L     16; //17=0->16
          TAK   ; 
          >=I   ; 
          SPB   oo2; 
          L     0; 
    oo2:  T     #Sindex; 
          SET   ; 
          =     #Besetzt; 
    oo1:  BE    ; 
    END_FUNCTION_BLOCK
    FIFO1.zip

    Gibt es eine kompaktere Methode (siehe blau ) aber ohne über den Lokalspeicher ?

  4. #4
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Standard

    TAD+TAW sind doch schneller als "SRD 16" oder ?


    Code:
     L 8; 
    /I;   
      PUSH; 
      SRD 16 ;
     LAR1  ;      
      POP;       
      SLD 3;        
     +AR1; 
    (Änderung: dummes löschen!)
    Geändert von 00alex (31.05.2013 um 16:07 Uhr)

  5. #5
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

  6. #6
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Rotes Gesicht

    Ein FIFO FB der Daten , in UDT Format aus einer DatenbausteinX in einer Queue speichert und geordnet in einem
    DatenbausteinY schreibt ( einfache Übung für Pointer + Datenhandlung ).

    FIFOUDT.zip

    Flankengesteuert !

    Kann man es einfacher machen ?
    Geändert von 00alex (01.06.2013 um 02:24 Uhr)

  7. #7
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Standard

    TAD+TAW sind doch schneller als "SRD 16" oder ?


  8. #8
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Pfeil

    ALARM MELDUNGEN zu sind leicht dazu , zu IMPLEMENTIEREN !
    Speicher VOLL -> (#Lindex=#Sindex UND #Besetzt=1)
    Speicher LEER -> (#Lindex=#Sindex UND #Besetzt=0)

    ... usw

  9. #9
    00alex ist offline Gesperrt
    Themenstarter
    Registriert seit
    01.05.2013
    Beiträge
    345
    Danke
    174
    Erhielt 3 Danke für 3 Beiträge

    Cool

    Obwohl man diese Programmchen benutzen könnte , sie nicht zu ernst nehmen

    Es sind ja nur :

  10. Folgender Benutzer sagt Danke zu 00alex für den nützlichen Beitrag:

    Perfektionist (04.06.2013)

  11. #10
    Registriert seit
    05.12.2013
    Ort
    Graz / Austria
    Beiträge
    149
    Danke
    9
    Erhielt 2 Danke für 2 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    "Schreiben" vor dem "Lesen" wäre vielleiht angenemer ...

Ähnliche Themen

  1. Rechenoperationen (DINT mit INT)
    Von Son1317 im Forum Simatic
    Antworten: 11
    Letzter Beitrag: 06.02.2013, 12:48
  2. Von REAL auf INT mit Komma umwandeln
    Von MasterKalle im Forum Simatic
    Antworten: 15
    Letzter Beitrag: 19.10.2011, 15:00
  3. Achsbewegung (REAL oder INT) in BOOL ausgeben
    Von MunoRodriguez im Forum CODESYS und IEC61131
    Antworten: 22
    Letzter Beitrag: 26.09.2011, 20:44
  4. Int / Dint
    Von Gerri im Forum Simatic
    Antworten: 3
    Letzter Beitrag: 09.07.2008, 11:14
  5. Antworten: 7
    Letzter Beitrag: 29.08.2006, 18:40

Lesezeichen

Berechtigungen

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