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

00alex

Level-1
Beiträge
345
Reaktionspunkte
3
Zuviel Werbung?
-> Hier kostenlos registrieren
Ringpuffer FIFO ! (INT;BOOL)

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


Anhang anzeigen 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)
 
Zuletzt bearbeitet:
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 !
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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; 

      [COLOR="#0000CD"]L     8; 
      /I    ; 
      PUSH  ; 
      TAD   ; 
      TAW   ; 
      UW    W#16#FF; 
      LAR1  ; 
      POP   ; 
      UW    W#16#FF; 
      SLD   3; 
      +AR1  ; 
[/COLOR]

      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; 

      [COLOR="#0000CD"]L     8; 
      /I    ; 
      PUSH  ; 
      TAD   ; 
      TAW   ; 
      UW    W#16#FF; 
      LAR1  ; 
      POP   ; 
      UW    W#16#FF; 
      SLD   3; 
      +AR1  ; [/COLOR]

      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
Anhang anzeigen FIFO1.zip

Gibt es eine kompaktere Methode (siehe blau :) ) aber ohne über den Lokalspeicher ?
 
TAD+TAW sind doch schneller als "SRD 16" oder ?
;)

Code:
[COLOR=#0000CD] L 8; 
[/COLOR][COLOR=#0000CD]/I;   
  PUSH; 
  [/COLOR][COLOR=#800080]SRD 16 ;[/COLOR][COLOR=#0000CD]
 LAR1  ;      
  POP;      [/COLOR][COLOR=#0000CD] 
  SLD 3;  [/COLOR][COLOR=#0000CD]      
 +AR1; [/COLOR]

(Änderung: dummes löschen!)
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
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 ).

Anhang anzeigen FIFOUDT.zip

Flankengesteuert !

Kann man es einfacher machen ?:confused:
 
Zuletzt bearbeitet:
ALARM MELDUNGEN zu sind leicht dazu , zu IMPLEMENTIEREN !
Speicher VOLL -> (#Lindex=#Sindex UND #Besetzt=1)
Speicher LEER -> (#Lindex=#Sindex UND #Besetzt=0)

... usw
 
Zurück
Oben