Step 7 Radixsort

00alex

Level-1
Beiträge
345
Reaktionspunkte
3
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

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

:D
 
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.
 
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 !
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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...
 
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 !
 
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

Anhang anzeigen 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)
 
Zuletzt bearbeitet:
Na ja, wird doch. Mit den Kommentaren und dem Wiki kann man es zumindest mal in der Übersicht erfassen.
Für mich stellt sich die Frage, ob genau dafür SCL nicht geeigneter wäre, dann wie man sieht, ist das in AWL in keinster Weise selbsterklärend. Aber das nur so nebenbei, AWL ist auch nicht umsonst.
 
ich würds auch in SCL machen wollen. Den Wiki-Artikel hatte ich schon gelesen, bevor der Link hier stand, durch den AWL-Verhau habe ich mich nicht durchgequählt. Ansonsten ist Radixsort ein schöner Denkanstoß auf den ich gerne zurückgreifen werde, wenn sich irgendwann einmal die Notwendigkeit ergeben sollte.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
RADIXSORT mit LONG INTEGER ... ;)

Anhang anzeigen RADIXSORT_DINT.zip

Könnte auch einen RADIXSORT Algorithmus für REAL zahlen schreiben ... usw.
Falls jemand "Lust und Laune" hat möge mir bei den 3 geposteten Fragen helfen ( im Ernst :cry:).

(Für mich haben sich diese Übungen obwohl nicht unbedingt "praktisch" gelohnt ! Habe ein tiefere Verständniss der Pointer und Datenformaten)
 
RADIXSORT mit LONG INTEGER ... ;)

Anhang anzeigen 20898

Falls jemand "Lust und Laune" hat möge mir bei den 3 geposteten Fragen helfen ( im Ernst :cry:).

Bau doch einfach mal eine UDT und Struct ein und versuche darauf zuzugreifen. Für Iterationen ist das eher ungeeignt, der große Vorteil ist, dass man im FB/FC die Variablen in der definierten UDT/Struct direkt nutzen kann.
Im Prinzip ist das einfach ein Container, den man komplett übergibt.
 
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 ?
zu 1: Rechtsklick in den Bausteinordner des Simatikmanagers-->Objekt einfügen-->Datentyp.
zu 2 kann ich nichts sagen.
zu 3 sollte eigentlich das Hilfesystem von Step recht rasch die Antwort liefern.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Vielen Dank !

Also @Ralle mit UDT ("IN","OUT") deklarieren wäre das gleiche wie mit BlockDB deklarieren ? ... sonst "kommen die Daten nicht in den Lokalbereich der aufrufende FB-s ? UDT sind ja nur "EINGABEMASKEN" oder ?

Und STRUCT deklarieren im "IN" ("OUT") bedeutet man hat aus dem FB Zugriff auf die Daten in den deklarierten (UDTs , STRUCTs) als wären sie ... global ?

@Perfektionist DANKE ... wollte aber was anders wissen ( mea culpa!) :
Wenn man eine UDT als "OUT" deklariert wird nur die "Maske" und die "Startwerten" weitergereicht , oder auch die aktuellen Werten ?
Was passiert beim STRUCT als "OUT"-Variable deklarieren ... werden wirklich alle Structdaten weitergereicht oder nur Zugrif darauf erlaubt ..."Daten für andere Bausteine durch die Deklaration im "OUT" sichtbar machen ?

:cry:
 
Da das bei zusammengesetzten Typen ja per Zeiger passiert, greift man sozusagen nach "außen" durch. Das bedeutet u.a. auch, dass man in einem sochen Falle u.U. auf eine IN-Variable schreiben kann und das kommt "außen" auch an. Hier muß man ein wenig aufpassen, dass man Leute, die später mit diesen Bausteinen arbeiten sollen, nicht verwirrt, also Kommentare schreiben!!! Wir hatten das vor kurzem hier im Forum kurz diskutiert, ich versuche dann IN_OUT zu nutzen (wenn es denn geht).
Wenn du UDT im FB deklarierst, mußt du ja außen an die Schnittstelle des FB auch die UDT (als globaler DB oder als Teil eines globalen DB) antragen. Diese Daten sind dann im FB/FC verfügbar.
 
Habe ein vereinfachtes Beispielprogramm geschrieben (wie man das Sortierverfahren benutzen könnte (mangels ...usw) :

RADIXSORT ist STABIL !

Anhang anzeigen RADIXSORT_STABIL.zip

Einfach die Integer in den OB1 (Testladen des DB) testen und ändern ! ... bei gleiche Werte die Ordnug bleibt erhalten auch nach dem Sortieren !

usw.

( Die Buchstaben in den DB sind "OBJEKTE" und die INTEGER deren Sortiereigenschaften !)

zB : a=234 ; b=-6573 ; c=-2 ...usw


( man mit Pointer und AWL ...vieles machen ;) )
 
Zuletzt bearbeitet:
Zurück
Oben