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

Seite 4 von 10 ErsteErste ... 23456 ... LetzteLetzte
Ergebnis 31 bis 40 von 97

Thema: Radixsort

  1. #31
    Registriert seit
    03.04.2008
    Beiträge
    6.200
    Danke
    237
    Erhielt 815 Danke für 689 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von 00alex Beitrag anzeigen
    ?
    SPS
    (der Rest ist Privatsache , tut mir Leid !)
    AUTSCH


    bike
    "Any fool can write code that a computer can understand.
    Good programmers write code that humans can understand."
    --Martin Fowler

  2. #32
    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:
    FUNCTION_BLOCK FB 1
    TITLE =
    VERSION : 0.1
    
    
    VAR_INPUT
      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)
      TEILUNG : INT ;	
    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 
      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)
      TEILEN : INT ;	
    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
      DWNr_Sort : DWORD ;	//DWord Adresse  im (gerade) sortierendem DB
      DWNr_Help : DWORD ;	//DWord Adresse  im (gerade) hifls DB
      M : DWORD ;	
    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#4; //DWORD = 4 BYTE
          /D    ; 
          +     L#-1; //(zählt von 0 !)
          L     L#32; //DWORD = 32 BIT
          *D    ; 
          T     #BITMENGE; 
          CLR   ; 
          =     #AUSWAHLBIT; 
          L     L#0; 
          T     #STEP; 
          T     #TEILEN; 
          SET   ; 
          =     #BUSY; 
    ENDE: NOP   0; 
    NETWORK
    TITLE =
    
          L     #TEILEN; 
          L     0; 
          <>I   ; 
          SPB   s3; 
    NETWORK
    TITLE =
    //UNTERBRECHMOGLICHKET (BUSY Rücksetzen) und SPRUNG falls BUSY 0
          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    ; 
          T     #M; 
          L     L#0; 
          ==D   ; 
          L     L#24; 
          SPB   B1; 
          L     #M; 
          L     L#1; 
          ==D   ; 
          L     L#16; 
          SPB   B1; 
          L     #M; 
          L     L#2; 
          ==D   ; 
          L     L#8; 
          SPB   B1; 
          L     #M; 
          L     L#3; 
          ==D   ; 
          L     L#0; 
    B1:   T     #ADRESSE_Sort; 
          L     #STEP; 
          L     L#16; 
          MOD   ; //Teilen auf  Periode von 0-31 (= bits in 1 dword)   
          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     #DWNr_Sort; 
          T     #DWNr_Help; 
          L     #DBNO_Sort; 
          T     #DBNO_tempS; 
          L     #DBNO_Help; 
          T     #DBNO_tempH; 
    NETWORK
    TITLE =
    //INITIALISIERDATEN für Datentransfer 
    //TRUEBIT 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    ; 
          T     #M; 
          L     L#0; 
          ==D   ; 
          L     #BITMENGE; 
          +     L#24; 
          SPB   B2; 
          L     #M; 
          L     L#1; 
          ==D   ; 
          L     #BITMENGE; 
          +     L#16; 
          SPB   B2; 
          L     #M; 
          L     L#2; 
          ==D   ; 
          L     #BITMENGE; 
          +     L#8; 
          SPB   B2; 
          L     #M; 
          L     L#3; 
          ==D   ; 
          L     #BITMENGE; 
    B2:   L     #BIT_Sort; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     #BITMENGE; 
          T     #DWNr_Sort; 
          T     #DWNr_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    ; 
          T     #M; 
          L     L#0; 
          ==D   ; 
          L     L#24; 
          SPB   B3; 
          L     #M; 
          L     L#1; 
          ==D   ; 
          L     L#16; 
          SPB   B3; 
          L     #M; 
          L     L#2; 
          ==D   ; 
          L     L#8; 
          SPB   B3; 
          L     #M; 
          L     L#3; 
          ==D   ; 
          L     L#0; 
    B3:   T     #ADRESSE_Sort; 
          L     #STEP; 
          L     L#16; 
          MOD   ; //Teilen auf  Periode von 0-31 (= bits in 1 dword)   
          L     L#2; 
          /D    ; 
          T     #BIT_Help; 
          L     #ADRESSE_Sort; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     L#0; 
          T     #DWNr_Sort; 
          T     #DWNr_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    ; 
          T     #M; 
          L     L#0; 
          ==D   ; 
          L     #BITMENGE; 
          +     L#24; 
          SPB   B4; 
          L     #M; 
          L     L#1; 
          ==D   ; 
          L     #BITMENGE; 
          +     L#16; 
          SPB   B4; 
          L     #M; 
          L     L#2; 
          ==D   ; 
          L     #BITMENGE; 
          +     L#8; 
          SPB   B4; 
          L     #M; 
          L     L#3; 
          ==D   ; 
          L     #BITMENGE; 
    B4:   L     #BIT_Help; 
          +D    ; 
          T     #ADRESSE_Sort; 
          L     #BITMENGE; 
          T     #DWNr_Sort; 
          T     #DWNr_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->MAX(RADIXSORT = STABIL)
    oo0:  NOP   0; 
    o3:   L     #DWNr_Sort; 
          L     #BITMENGE; //(0->6)[7]
          >D    ; 
          SPB   o1; 
          AUF   DB [#DBNO_tempS]; 
          U     DBX [#ADRESSE_Sort]; 
          SPB   o2; 
          L     DBD [#DWNr_Sort]; 
          AUF   DB [#DBNO_tempH]; 
          T     DBD [#DWNr_Help]; 
          L     #DWNr_Help; 
          +     L#32; // WORD=16
          T     #DWNr_Help; 
    o2:   NOP   0; 
          L     #ADRESSE_Sort; 
          +     L#32; 
          T     #ADRESSE_Sort; 
          L     #DWNr_Sort; 
          +     L#32; 
          T     #DWNr_Sort; 
          L     #TEILEN; 
          +     1; 
          T     #TEILEN; 
          L     #TEILUNG; 
          MOD   ; 
          L     0; 
          ==I   ; 
          SPB   FIN; 
          SPA   o3; 
    o1:   L     0; 
          T     #TEILEN; 
          SET   ; 
          =     #AUSWAHLBIT; 
          L     #STEP; 
          +     L#1; 
          T     #STEP; 
          BE    ; 
    NETWORK
    TITLE =
    //EINSER sortieren
    //Hier werden alle TRUE-im-ABRAGEBIT DB-WORDS Transferiert
    //REIHENFOLGE von MAX->0 (RADIXSORT = STABIL)
    oo1:  NOP   0; 
    o6:   L     #DWNr_Sort; 
          L     L#0; 
          <D    ; 
          SPB   o4; 
          AUF   DB [#DBNO_tempS]; 
          UN    DBX [#ADRESSE_Sort]; 
          SPB   o5; 
          L     DBD [#DWNr_Sort]; 
          AUF   DB [#DBNO_tempH]; 
          T     DBD [#DWNr_Help]; 
          L     #DWNr_Help; 
          +     L#-32; 
          T     #DWNr_Help; 
    o5:   NOP   0; 
          L     #ADRESSE_Sort; 
          +     L#-32; 
          T     #ADRESSE_Sort; 
          L     #DWNr_Sort; 
          +     L#-32; 
          T     #DWNr_Sort; 
          L     #TEILEN; 
          +     1; 
          T     #TEILEN; 
          L     #TEILUNG; 
          MOD   ; 
          L     0; 
          ==I   ; 
          SPB   FIN; 
          SPA   o6; 
    o4:   L     0; 
          T     #TEILEN; 
          CLR   ; 
          =     #AUSWAHLBIT; 
          L     #STEP; 
          +     L#1; 
          T     #STEP; 
          L     L#64; 
          <D    ; 
          SPB   FIN; 
          CLR   ; 
          =     #BUSY; 
    FIN:  BE    ; 
    
    END_FUNCTION_BLOCK
    PROGG ist so geändert das man über dem Parameter TEILUNG die gebrauchte Zeit pro Zyklus unterkritisch halten kann !

    Gibt es feinere auch Alternativen ?

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

    Standard

    TEST_RADIX.zip

    ....................................................

  4. #34
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.716
    Danke
    398
    Erhielt 2.398 Danke für 1.998 Beiträge

    Standard

    Zitat Zitat von 00alex Beitrag anzeigen
    @wolder ... du muss es erkennen das ich ein feiner Kerl war !
    Stimmt ... bist du bestimmt irgendwann einmal gewesen ...

    Zitat Zitat von 00alex Beitrag anzeigen
    ...bin nicht grob drauf gegangen und den Unsinn sofort angezeigt sondern eher mäeutisch vorgegangen ... das hat aber einige "g'scheite" ... bloßgestellt ... die wie immer ... vormaulig waren/sind !
    Welchen "Gescheiten" hast du denn blossgestellt ?
    Mir ist nur aufgefallen, dass du bei ein paar "Gescheiten" versucht hast, denen auf den Keks zu gehen - bloss stellen heißt : eine getroffene Aussage widerlegen ...

    Ach ja ... und auch dieser Thread wird wohl sehr wahrscheinlich früher oder später im SV landen ...

    Gruß
    Larry

    @Wolder:
    Sicherlich ist der Gedanke an sich interessant - aber würdest du das in AWL machen ?
    Ich würde jede Form der Sortierung oder sonstige Daten-Aufbereitung in SCL schreiben ... schon allein, dass auch jemand anderes das mal verstehen kann ...

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

    Standard

    Bei diesem Thread bin ich fertig ! ... du entscheidest ob auch andere in der Zukunft daran teilhaben können !
    PS: Es liegt allein in deiner Macht die anderen es vermüllen lassen

  6. #36
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.716
    Danke
    398
    Erhielt 2.398 Danke für 1.998 Beiträge

    Standard

    Sorry ... aber fertig (mit was auch immer) bist du m.E. schon etwas länger ...
    Ach ja ... und für das Voll-Müllen brauchst du nicht die Anderen - die reagieren nur - der Eine so, der Andere so ...

  7. #37
    Registriert seit
    23.03.2006
    Ort
    Thüringen
    Beiträge
    2.005
    Danke
    162
    Erhielt 278 Danke für 199 Beiträge

    Standard

    Also,
    du entscheidest ob auch andere in der Zukunft daran teilhaben können !
    An was bitte? Das was hier präsentiert wird kann man in einem billigen PAP, einem Struktogramm in C oder wasweißich durchexerzieren. Also teilhaben, wer bitteschön?
    Ein Anfänger fängt mit Logikaufgaben an, die komplexeren Dinge werden hier sowieso beherrscht und wenn einer dazu eine Frage hat bekommt er die kompetent beantwortet, und das auch schon vor Deiner Anwesenheit.

    Ich fasse es nicht
    Mario

  8. #38
    Registriert seit
    06.10.2003
    Beiträge
    3.409
    Danke
    449
    Erhielt 504 Danke für 407 Beiträge

    Standard

    Zitat Zitat von 00alex Beitrag anzeigen
    Die THEORIE dahinter ist unglaublich einfach deswegen habe das unkommentiert gelassen :
    - es ist einfach RADIXSORT der beste Sortieralgorithmus der Welt für PLC !..
    Ohh wirklich?

    Zitat Zitat von 00alex Beitrag anzeigen
    ..PROGG ist so geändert das man über dem Parameter TEILUNG die gebrauchte Zeit pro Zyklus unterkritisch halten kann !..
    Ganz toll!

    Upps, Widersprüche? Vielleicht ein bisschen viel Theorie aber null Praxis? Ich gebe zu, ich habe noch nicht versucht, es zu verstehen. Wann brauche ich so etwas in einer Steuerung? Praktische Beispiele?


    Gruß, Onkel
    Es gibt viel mehr Leute, die freiwillig aufgeben, als solche, die echt scheitern.
    Henry Ford

  9. #39
    Registriert seit
    03.04.2008
    Beiträge
    6.200
    Danke
    237
    Erhielt 815 Danke für 689 Beiträge

    Standard

    Onkel, musst du nur hier:

    Radixsort

    lesen.

    Also viel Erfolg beim Birnen, Äpfel, Zwetschken sortieren


    bike
    "Any fool can write code that a computer can understand.
    Good programmers write code that humans can understand."
    --Martin Fowler

  10. #40
    Registriert seit
    17.07.2009
    Ort
    Am Rande der Ostalb
    Beiträge
    5.480
    Danke
    1.141
    Erhielt 1.240 Danke für 973 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von Onkel Dagobert Beitrag anzeigen
    Wann brauche ich so etwas in einer Steuerung? Praktische Beispiele?
    Ich brauche Sortierfunktionen auch nicht täglich, aber sie kommen schon öfters vor.
    Letzte Verwendung bei mir war die Verwaltung von Qualitäts- und Auftragsdaten.
    Wegoptimierung von NC-Verfahrsätzen war auch schon mal ein Thema

    Bislang hat mir eigentlich immer ein simples Bubblesort gereicht.
    In S5 hab ich mal ein Quicksort implemtiert. War damals nicht sonderlich lustig, da es über zig DB ging.
    Heute mit SCL ist es wesentlich einfacher.

    Wenn ich mir die Theorie hinter Radix-Sort anschaue, dann muß ich der Aussage von 00Alex widersprechen.
    Es ist nicht der beste Sortieralgorithmus für SPS. Die Aussage gilt - meines Erachtens - nur für Bitfelder, Integer und bestimmte Strings mit Kriterien.
    Bei DINT, Real, unstrukturierten Strings schrumpfen die Vorteile ganz schnell.

    Gruß
    Dieter
    Geändert von Blockmove (18.06.2013 um 23:19 Uhr)

  11. Folgender Benutzer sagt Danke zu Blockmove für den nützlichen Beitrag:

    Onkel Dagobert (21.06.2013)

Lesezeichen

Berechtigungen

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