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

Seite 1 von 10 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 97

Thema: Radixsort

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

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Code:
     FUNCTION_BLOCK FB 1TITLE =
    VERSION : 0.1
    
    
    
    
    VAR_INPUT
      ABBRUCH : BOOL ;	
      START : BOOL ;	
      sortDB : BLOCK_DB ;	
      helpDB : BLOCK_DB ;	
    END_VAR
    VAR_OUTPUT
      BUSY : BOOL ;	
    END_VAR
    VAR
      STARTflanke : BOOL ;	
      sortDBnummer : WORD ;	
      helpDBnummer : WORD ;	
      Auswahlbit : DWORD ;	
      MNGKlein : DWORD ;	
      MNGGross : DWORD ;	
      count : DWORD ;	
      M0 : DWORD ;	
      M1 : DWORD ;	
    END_VAR
    VAR_TEMP
      sortDBtempN : WORD ;	
      helpDBtempN : WORD ;	
      x : DWORD ;	
      y : DWORD ;	
      z : DWORD ;	
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    //START + iNITIALISIEREN
          U     #START; 
          FP    #STARTflanke; 
          SPBN  ENDE; 
          AUF   #helpDB; 
          L     DBNO; 
          T     #helpDBnummer; 
          AUF   #sortDB; 
          L     DBNO; 
          T     #sortDBnummer; 
          L     DBLG; 
          L     L#2; 
          /D    ; 
          L     L#1; 
          -D    ; 
          L     L#16; 
          *D    ; 
          T     #MNGKlein; 
          L     L#8; 
          +D    ; 
          T     #MNGGross; 
          L     L#0; 
          T     #Auswahlbit; 
          T     #count; 
          SET   ; 
          =     #BUSY; 
    ENDE: NOP   0; 
    NETWORK
    TITLE =
    //UNTERBRECHMOGLICHKET
          U     #ABBRUCH; 
          R     #BUSY; 
          UN    #BUSY; 
          SPB   LAU; 
    NETWORK
    TITLE =
    //FALL 1 KOMPAKT
          U(    ; 
          L     #count; 
          L     L#0; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#4; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#8; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#12; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#16; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#20; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#24; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#28; 
          <>D   ; 
          )     ; 
          SPB   s0; 
          L     #count; 
          L     L#16; 
          >=D   ; 
          L     L#8; 
          L     L#0; 
          SPB   VK1; 
          TAK   ; 
    VK1:  T     #x; 
          L     #count; 
          L     L#16; 
          MOD   ; 
          L     L#2; 
          /D    ; 
          T     #M0; 
          L     #x; 
          +D    ; 
          T     #x; 
          L     L#0; 
          T     #y; 
          T     #z; 
          L     #sortDBnummer; 
          T     #sortDBtempN; 
          L     #helpDBnummer; 
          T     #helpDBtempN; 
    NETWORK
    TITLE =
    //FALL 2  KOMPAKT
    s0:   NOP   0; 
          U(    ; 
          L     #count; 
          L     L#1; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#5; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#9; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#13; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#17; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#21; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#25; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#29; 
          <>D   ; 
          )     ; 
          SPB   s1; 
          L     #count; 
          L     L#16; 
          >=D   ; 
          L     #MNGGross; 
          L     #MNGKlein; 
          SPB   VK2; 
          TAK   ; 
    VK2:  T     #x; 
          L     #M0; 
          L     #x; 
          +D    ; 
          T     #x; 
          L     #MNGKlein; 
          T     #y; 
          T     #z; 
          L     #sortDBnummer; 
          T     #sortDBtempN; 
          L     #helpDBnummer; 
          T     #helpDBtempN; 
    NETWORK
    TITLE =
    //FALL 3  KOMPAKT
    s1:   NOP   0; 
          U(    ; 
          L     #count; 
          L     L#2; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#6; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#10; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#14; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#18; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#22; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#26; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#30; 
          <>D   ; 
          )     ; 
          SPB   s2; 
          L     #count; 
          L     L#16; 
          >=D   ; 
          L     L#8; 
          L     L#0; 
          SPB   VK3; 
          TAK   ; 
    VK3:  T     #x; 
          L     #count; 
          L     L#16; 
          MOD   ; 
          L     L#2; 
          /D    ; 
          T     #M1; 
          L     #x; 
          +D    ; 
          T     #x; 
          L     L#0; 
          T     #y; 
          T     #z; 
          L     #sortDBnummer; 
          T     #helpDBtempN; 
          L     #helpDBnummer; 
          T     #sortDBtempN; 
    NETWORK
    TITLE =
    //FALL 4  KOMPAKT
    s2:   NOP   0; 
          U(    ; 
          L     #count; 
          L     L#3; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#7; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#11; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#15; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#19; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#23; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#27; 
          <>D   ; 
          )     ; 
          U(    ; 
          L     #count; 
          L     L#31; 
          <>D   ; 
          )     ; 
          SPB   s3; 
          L     #count; 
          L     L#16; 
          >=D   ; 
          L     #MNGGross; 
          L     #MNGKlein; 
          SPB   VK4; 
          TAK   ; 
    VK4:  T     #x; 
          L     #M1; 
          L     #x; 
          +D    ; 
          T     #x; 
          L     #MNGKlein; 
          T     #y; 
          T     #z; 
          L     #sortDBnummer; 
          T     #helpDBtempN; 
          L     #helpDBnummer; 
          T     #sortDBtempN; 
    s3:   NOP   0; 
    NETWORK
    TITLE =
    //AUSWAHL 0
          L     #Auswahlbit; 
          L     L#0; 
          ==D   ; 
          SPB   oo0; 
    NETWORK
    TITLE =
    //AUSWAHL 1
          L     #Auswahlbit; 
          L     L#1; 
          ==D   ; 
          SPB   oo1; 
    NETWORK
    TITLE =
    //SEPARATOR
    LAU:  BE    ; 
    
    
    NETWORK
    TITLE =
    //ZEROS sortieren
    oo0:  NOP   0; 
    o3:   L     #y; 
          L     #MNGKlein; //(0->6)[7]
          >D    ; 
          SPB   o1; 
          AUF   DB [#sortDBtempN]; 
          U     DBX [#x]; 
          SPB   o2; 
          L     DBW [#y]; 
          AUF   DB [#helpDBtempN]; 
          T     DBW [#z]; 
          L     #z; 
          L     16; // WORD=16
          +D    ; 
          T     #z; 
    o2:   NOP   0; 
          L     #x; 
          L     L#16; 
          +D    ; 
          T     #x; 
          L     #y; 
          L     L#16; 
          +D    ; 
          T     #y; 
          SPA   o3; 
    o1:   L     L#1; 
          T     #Auswahlbit; 
          L     #count; 
          L     L#1; 
          +D    ; 
          T     #count; 
          BE    ; 
    NETWORK
    TITLE =
    //EINSER sortieren
    
    
    oo1:  NOP   0; 
    o6:   L     #y; 
          L     L#0; 
          <D    ; 
          SPB   o4; 
          AUF   DB [#sortDBtempN]; 
          UN    DBX [#x]; 
          SPB   o5; 
          L     DBW [#y]; 
          AUF   DB [#helpDBtempN]; 
          T     DBW [#z]; 
          L     #z; 
          L     L#16; 
          -D    ; 
          T     #z; 
    o5:   NOP   0; 
          L     #x; 
          L     L#16; 
          -D    ; 
          T     #x; 
          L     #y; 
          L     L#16; 
          -D    ; 
          T     #y; 
          SPA   o6; 
    o4:   L     L#0; 
          T     #Auswahlbit; 
          L     #count; 
          L     L#1; 
          +D    ; 
          T     #count; 
          L     L#32; 
          <D    ; 
          SPB   FIN; 
          CLR   ; 
          =     #BUSY; 
    FIN:  BE    ; 
    
    
    END_FUNCTION_BLOCK
    RADIXSORT.zip
    Zitieren Zitieren Radixsort  

  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

    Das obige Programm funktioniert (nur) mit (positive) INTEGER , zum testen einfach einen DB mit random (positive) INTEGER füllen dannach den DB (auch!) unter anderem Nummer speichern ( als SORTIER Hilfsplatz ) , nach START sollen in dem ursprunglichen DB alle INTEGER sortiert sein ....

    (Es solle also nötig: 2 DB-s gleicher grosse , einen mit den sortierenden INT und der andere als SORTIERHILFE)

    ... es ist nur eine quick&dirty Übung (für POINTER , DB-s und Byte+Word+...) ...es ginge noch kompakter und schneller !
    Geändert von 00alex (11.06.2013 um 03:24 Uhr)

  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

    Standard

    Sortiert auch NEGATIVE integer ( auch gemischt ).

    (Sortiertung von klein bis gross für positive INT und das gleiche für negative INT ).

    Man sieht sogar die AWL beim sortieren ...


  4. #4
    Registriert seit
    27.05.2004
    Ort
    Thüringen/Berlin
    Beiträge
    12.227
    Danke
    534
    Erhielt 2.698 Danke für 1.950 Beiträge

    Standard

    Ich bin ja im Allgemeinen als ganz verträglich bekannt, aber nun gehst du mir doch langsam auf die Ei...

    Entweder du kommentierst deine Softwareergüsse anständig und schreibst vielleicht noch was genau du im Code machst oder du behältst den Mist für dich!
    Auch wenn du es anscheinend nicht kapieren willst, niemand macht sich die Mühe, deinen Spagetticode zu lesen, weil das ohne Kenntniss deines Ansatzes und der Theorie dahinter einfach sinnlos, anstrengend und zeitraubend ist. Für mich ist das einfach eine Beleidigung und ich stufe das als Spam ein. Deswegen die Verwarnung, als nächstes fliegst du. Ich hoffe, mich klar ausgedrückt zu haben und damit auch in deinem völlig beratungsresistenten Gehirn angekommen zu sein.
    Gruß
    Ralle

    ... there\'re 10 kinds of people ... those who understand binaries and those who don\'t …
    and the third kinds of people … those who love TIA-Portal

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

    00alex (11.06.2013)

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

    Standard

    Die THEORIE dahinter ist unglaublich einfach deswegen habe das unkommentiert gelassen :
    - es ist einfach RADIXSORT der beste Sortieralgorithmus der Welt für PLC !
    Es ist kein Spagettikode!
    Assembler und AWL kann man nur mit "Sprünge" und "Schleifen" programmieren weil es die Konstrukten der "höheren" Sprachen nicht hat ( das soll nicht bedeuten das diese Sprachen nicht Turing-universal wären ).

    Ich wollte ein RADIXSORT algorithmus für REAL-zahlen schreiben ( es ist fast genau so einfach !) ... barucht aber ein par "triks" die der INT-algorithmus nicht braucht ... usw.

    (Ein Anfänger würde es vieleicht , vieleicht den geposteten Programm nicht verstehen nicht mal erklärt ! ein erfahrene Instandhalter aber schon , würde nicht mal Hinweise brauchen !) .

    Ich habe es gepostet als Gegenleistung für einige Hinweise die ich von ihnen erwarte :

    1-Bei Variablen deklarieren IN,OUT,IN-OUT kann man UDT-s deklarieren WIE FUNKIONIERT DAS ? WIE GEHT DAS OHNE BLOCKMOVE ? ( ich kapiere es nicht !)

    2-Das gleiche für "STRING" ... kan man STRING-s analitisch generieren ?

    3- "STRUCT" auch in IN,OUT Variablendeklaration ( bedeutet das das man sie direkt liefern kann obwohl sie langer als ...32Bits sind ?

    Ich bin sonst mit der AWL fast durch ( kann fast alles damit lösen ).

    Fange mit SCL an ( könne Übungen posten wenn jemand Interese hat , als Gegenleistung für Hinweise die ich von euch erwarte !) .

    Nur noch ein Thread mit KETTENSCHRITTEN und die implementier-STRATEGIEN mündlicher Automatiesierungs Problemen in AWL .

    ( könnte auch ein Thread : Matematikfunktionen mit AWL ... Quantorenalgebra und FUZZY-Regelungsalgorithmen schreiben ... hab aber keine Lust alles zu kommentieren ...usw.)


    SCL scheint 2/3 "leichter" zu lernen sein als AWL

    DANKE im Voraus für ihre Antworten bezüglich meiner obigen 3 Fragen ! ... bin noch fleissig beim lernen und üben !

    ( Falls jemand punktuelle Erklärungen zu den obigen RADIXSORT Programm haben möchte dann fragen ! Werde antworten !

  7. #6
    Registriert seit
    27.05.2004
    Ort
    Thüringen/Berlin
    Beiträge
    12.227
    Danke
    534
    Erhielt 2.698 Danke für 1.950 Beiträge

    Standard

    Hast du ne Macke du Genie?
    Die meißten Leute hier sind hart am arbeiten und helfen so nebenbei, opfern dafür ihre Freizeit.
    Wenn du hier postest, dann kannst du gar nichts erwarten, i.d.R. noch nicht mal ein Danke, so ist das nun mal, gewöhn dich dran.

    Ansonsten bleib mit deinem Supercode allein und werd glücklich!

    Ende der Durchsage...
    Gruß
    Ralle

    ... there\'re 10 kinds of people ... those who understand binaries and those who don\'t …
    and the third kinds of people … those who love TIA-Portal

  8. Folgende 5 Benutzer sagen Danke zu Ralle für den nützlichen Beitrag:

    bike (12.06.2013),DerMatze (12.06.2013),JOHKU (22.06.2013),m_w (11.06.2013),wolder (11.06.2013)

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

    Daumen hoch

    Na ja ...! Es soll heissen "nur wenn jemand Lust und Laune hat" kein Zwang also ... (würde aber froh sein wenn mir jemand hilft ! ... könnte ihm als Gegenleistung (wenn möglich !) auch helfen !
    ...also "gegenseitigkeit" !

    Bin ein kein Genie ...eher 08-15 TYP (ist auch kein Superkode !) eher ... trockenes üben .

    Vieleicht findet sich (irgend ) jemand der mir hilft ....lieber @Rale ... muss nicht gleich sein !

  10. #8
    Registriert seit
    06.10.2009
    Ort
    NRW
    Beiträge
    1.572
    Danke
    63
    Erhielt 259 Danke für 219 Beiträge

    Standard

    Sag mal nimmst Du irgendwie abgelaufene Medikamente?

    Der Müll den Du hier von Dir gibst kann doch nicht bei klarem Verstand geschrieben worden sein.
    Meine Motivation läuft nackig mit einem Cocktail über eine Wiese.

  11. Folgende 2 Benutzer sagen Danke zu Tigerente1974 für den nützlichen Beitrag:

    cmm1808 (11.06.2013),DerMatze (12.06.2013)

  12. #9
    Registriert seit
    27.04.2005
    Beiträge
    200
    Danke
    22
    Erhielt 13 Danke für 10 Beiträge

    Standard

    Leute, Leute,

    bitte etwas mehr Ehrfurcht vor dem Entwickler des weltbesten Sortieralgorithmus!

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

    Lächeln


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Code:
    FUNCTION_BLOCK "RADIXSORT INT"
    TITLE =
    //VERLAUF -> 
    //Zu erst werden die Bits DBX x.0 aller Word in der SORT DB auf FALSE abgefragt 
    //und die zugehörige WORDS beim treffen nach HELP DB verschoben (füllen von unten 
    //nach oben) dannach werden die Bits DBX x.0 aller Word in der SORT DB auf TRUE 
    //abgefragt und die zugehörige WORDS beim treffen nach HELP DB verschoben (füllen 
    //von oben nach unten) 
    //dannach
    //DB Nummer in den variablen tauschen und mit DBX x.1 ROUTINE wiederholen 
    //dannach 
    //DB Nummer in den variablen tauschen und mit DBX x.2 ROUTINE wiederholen 
    //
    //usw.
    //
    //...bis DBX x.7
    VERSION : 0.1
    
    
    VAR_INPUT
      ABBRUCH : BOOL ;    //Lösen der remanenter BUSY fals Strommausfal
      START : BOOL ;    
      DB_Sort : BLOCK_DB ;    //DB mit den zu sortierenden INTEGER
      DB_Help : BLOCK_DB ;    //Hilfs DB mindestens so gross wie DB-Sort (muss nicht leer sein)
    END_VAR
    VAR_OUTPUT
      BUSY : BOOL ;    //Nicht fertig Meldung
    END_VAR
    VAR
      START_FM : BOOL ;    //Start Flankenmerker
      AUSWAHLBIT : BOOL ;    //Auswahl zwieschen Sortierungen
      DBNO_Sort : WORD ;    //Nummer DB_Sort
      DBNO_Help : WORD ;    //Nummer DB_Help
      BITMENGE : DWORD ;    //Durchlaufene Bitmenge 
      BITMENGE_PLUS : DWORD ;    //Durchlaufene Bitmenge + 1 BYTE
      STEP : DWORD ;    //SCHRITTNUMMER im ZYKLUS
      BIT_Sort : DWORD ;    //Die BITS zu den BYTE (von SortDB nach HelpDB)
      BIT_Help : DWORD ;    //Die BITS zu den BYTE (von HelpDB nach SortDB)
    END_VAR
    VAR_TEMP
      DBNO_tempS : WORD ;    //DBNO Variable 1
      DBNO_tempH : WORD ;    //DBNO Variable 2
      ADRESSE_Sort : DWORD ;    //Byte.Bit Adresse im (gerade) sortierendem DB
      WNr_Sort : DWORD ;    //Word Adresse  im (gerade) sortierendem DB
      WNr_Help : DWORD ;    //Word Adresse  im (gerade) hifls DB
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    //START + iNITIALISIEREN
          U     #START; 
          FP    #START_FM; 
          SPBN  ENDE; 
          AUF   #DB_Help; 
          L     DBNO; 
          T     #DBNO_Help; 
          AUF   #DB_Sort; 
          L     DBNO; 
          T     #DBNO_Sort; 
          L     DBLG; 
          L     L#2; //WORD = 2 BYTE
          /D    ; 
          L     L#1; //(zählt von 0 !)
          -D    ; 
          L     L#16; //WORD = 16 BIT
          *D    ; 
          T     #BITMENGE; 
          L     L#8; //1 BYTE
          +D    ; 
          T     #BITMENGE_PLUS; 
          CLR   ; 
          =     #AUSWAHLBIT; 
          L     L#0; 
          T     #STEP; 
          SET   ; 
          =     #BUSY; 
    ENDE: NOP   0; 
    NETWORK
    TITLE =
    //UNTERBRECHMOGLICHKET (BUSY Rücksetzen) und SPRUNG falls BUSY 0
          U     #ABBRUCH; 
          R     #BUSY; 
          UN    #BUSY; 
          SPB   WAIT; 
    NETWORK
    TITLE =
    //INITIALISIERDATEN für Datentransfer 
    //FALSEBIT WORDS von SORT DB nach HELP DB
          L     #STEP; //SCHRITTNUMMER
          L     L#4; //MOD 4 (ROUTINE_WIDERHOLFAKTOR)
          MOD   ; //ZYKLIZITÄT NÜTZEN
          L     L#0; //TYP 0
          <>D   ; 
          SPB   s0; 
          L     #STEP; 
          L     L#16; 
          <D    ; // BYTE GERADE oder UNGERADE im WORD ? 
          L     L#8; // Falls UNGERADE (1 BYTE = 8 BITS RECHTSVERSCHIEBEN )
          L     L#0; // Fals GERADE ( so lassen )
          SPBN  B1; 
          TAK   ; //Tausche AKKUS je nach ABFRAGE ERGEBNIS
    B1:   T     #ADRESSE_Sort; 
          L     #STEP; 
          L     L#16; //Teilen auf  Periode von 0-16 (= bits in 1 word)
          MOD   ; 
          L     L#2; 
          /D    ; //Nochmals Teilen auf Periode von 0-7 (= bits in 1 byte)
          T     #BIT_Sort; 
          L     #ADRESSE_Sort; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     L#0; 
          T     #WNr_Sort; 
          T     #WNr_Help; 
          L     #DBNO_Sort; 
          T     #DBNO_tempS; 
          L     #DBNO_Help; 
          T     #DBNO_tempH; 
    NETWORK
    TITLE =
    //INITIALISIERDATEN für Datentransfer 
    //TRUBIT WORDS von SORT DB nach HELP DB
    s0:   NOP   0; 
          L     #STEP; 
          L     L#4; 
          MOD   ; 
          L     L#1; 
          <>D   ; 
          SPB   s1; 
          L     #STEP; 
          L     L#16; 
          <D    ; 
          L     #BITMENGE_PLUS; 
          L     #BITMENGE; 
          SPBN  B2; 
          TAK   ; 
    B2:   L     #BIT_Sort; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     #BITMENGE; 
          T     #WNr_Sort; 
          T     #WNr_Help; 
          L     #DBNO_Sort; 
          T     #DBNO_tempS; 
          L     #DBNO_Help; 
          T     #DBNO_tempH; 
    NETWORK
    TITLE =
    //INITIALISIERDATEN für Datentransfer 
    //FALSEBIT WORDS von HELP DB nach SORT DB
    s1:   NOP   0; 
          L     #STEP; 
          L     L#4; 
          MOD   ; 
          L     L#2; 
          <>D   ; 
          SPB   s2; 
          L     #STEP; 
          L     L#16; 
          <D    ; 
          L     L#8; 
          L     L#0; 
          SPBN  B3; 
          TAK   ; 
    B3:   T     #ADRESSE_Sort; 
          L     #STEP; 
          L     L#16; 
          MOD   ; 
          L     L#2; 
          /D    ; 
          T     #BIT_Help; 
          L     #ADRESSE_Sort; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     L#0; 
          T     #WNr_Sort; 
          T     #WNr_Help; 
          L     #DBNO_Sort; 
          T     #DBNO_tempH; 
          L     #DBNO_Help; 
          T     #DBNO_tempS; 
    NETWORK
    TITLE =
    //INITIALISIERDATEN für Datentransfer 
    //TRUEBIT WORDS von HELP DB nach SORT DB
    s2:   NOP   0; 
          L     #STEP; 
          L     L#4; 
          MOD   ; 
          L     L#3; 
          <>D   ; 
          SPB   s3; 
          L     #STEP; 
          L     L#16; 
          <D    ; 
          L     #BITMENGE_PLUS; 
          L     #BITMENGE; 
          SPBN  B4; 
          TAK   ; 
    B4:   L     #BIT_Help; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     #BITMENGE; 
          T     #WNr_Sort; 
          T     #WNr_Help; 
          L     #DBNO_Sort; 
          T     #DBNO_tempH; 
          L     #DBNO_Help; 
          T     #DBNO_tempS; 
    s3:   NOP   0; 
    NETWORK
    TITLE =
    //AUSWAHL FALSEBIT_SORTIEREN
          UN    #AUSWAHLBIT; 
          SPB   oo0; 
    NETWORK
    TITLE =
    //AUSWAHL TRUEBIT_SORTIEREN
          U     #AUSWAHLBIT; 
          SPB   oo1; 
    NETWORK
    TITLE =
    //SEPARATOR
    WAIT: BE    ; 
    
    NETWORK
    TITLE =
    //ZEROS sortieren
    //Hier werden alle FALSE-im-ABRAGEBIT DB-WORDS Transferiert
    //REIHENFOLGE von 0->7(RADIXSORT = STABIL)
    oo0:  NOP   0; 
    o3:   L     #WNr_Sort; 
          L     #BITMENGE; //(0->6)[7]
          >D    ; 
          SPB   o1; 
          AUF   DB [#DBNO_tempS]; 
          U     DBX [#ADRESSE_Sort]; 
          SPB   o2; 
          L     DBW [#WNr_Sort]; 
          AUF   DB [#DBNO_tempH]; 
          T     DBW [#WNr_Help]; 
          L     #WNr_Help; 
          L     L#16; // WORD=16
          +D    ; 
          T     #WNr_Help; 
    o2:   NOP   0; 
          L     #ADRESSE_Sort; 
          L     L#16; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     #WNr_Sort; 
          L     L#16; 
          +D    ; 
          T     #WNr_Sort; 
          SPA   o3; 
    o1:   SET   ; 
          =     #AUSWAHLBIT; 
          L     #STEP; 
          L     L#1; 
          +D    ; 
          T     #STEP; 
          BE    ; 
    NETWORK
    TITLE =
    //EINSER sortieren
    //Hier werden alle TRUE-im-ABRAGEBIT DB-WORDS Transferiert
    //REIHENFOLGE von 7->0 (RADIXSORT = STABIL)
    oo1:  NOP   0; 
    o6:   L     #WNr_Sort; 
          L     L#0; 
          <D    ; 
          SPB   o4; 
          AUF   DB [#DBNO_tempS]; 
          UN    DBX [#ADRESSE_Sort]; 
          SPB   o5; 
          L     DBW [#WNr_Sort]; 
          AUF   DB [#DBNO_tempH]; 
          T     DBW [#WNr_Help]; 
          L     #WNr_Help; 
          L     L#16; 
          -D    ; 
          T     #WNr_Help; 
    o5:   NOP   0; 
          L     #ADRESSE_Sort; 
          L     L#16; 
          -D    ; 
          T     #ADRESSE_Sort; 
          L     #WNr_Sort; 
          L     L#16; 
          -D    ; 
          T     #WNr_Sort; 
          SPA   o6; 
    o4:   CLR   ; 
          =     #AUSWAHLBIT; 
          L     #STEP; 
          L     L#1; 
          +D    ; 
          T     #STEP; 
          L     L#32; 
          <D    ; 
          SPB   FIN; 
          CLR   ; 
          =     #BUSY; 
    FIN:  BE    ; 
    
    END_FUNCTION_BLOCK
    INT_RADIXSORT.zip

    Habe es kommentiert !
    RADIXSORT selbst ist hier erklärt :

    http://de.wikipedia.org/wiki/Radixsort

    RADIXSORT "ist gut" für SPS/PLC weil eine im voraus kalkulierbare ZEIT braucht , konstant von den Sortierdatenmenge abhängig und so die Verteilung auf mehrere Zyklen abhängig von der Sortierdatenmenge im voraus erlaubt ( hab's nicht implementiert !)

    (...hofe ihr könnt mir auch bei den oberen 3 Fragen helfen !)

    (Änderung falscher Progg aufgeladen)
    Geändert von 00alex (12.06.2013 um 13:06 Uhr)

Lesezeichen

Berechtigungen

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