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)
[COLOR="#FF0000"]TEILUNG : INT [/COLOR];
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)
[COLOR="#FF0000"] TEILEN : INT ;[/COLOR]
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;
[COLOR="#FF0000"]T #TEILEN; [/COLOR]
SET ;
= #BUSY;
ENDE: NOP 0;
NETWORK
TITLE =
[COLOR="#FF0000"] L #TEILEN;
L 0;
<>I ;
SPB s3; [/COLOR]
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;
[COLOR="#FF0000"] L #TEILEN;
+ 1;
T #TEILEN;
L #TEILUNG;
MOD ;
L 0;
==I ;
SPB FIN; [/COLOR]
SPA o3;
o1: [COLOR="#FF0000"]L 0;
T #TEILEN; [/COLOR]
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;
[COLOR="#FF0000"] L #TEILEN;
+ 1;
T #TEILEN;
L #TEILUNG;
MOD ;
L 0;
==I ;
SPB FIN; [/COLOR]
SPA o6;
o4: [COLOR="#FF0000"]L 0;
T #TEILEN; [/COLOR]
CLR ;
= #AUSWAHLBIT;
L #STEP;
+ L#1;
T #STEP;
L L#64;
<D ;
SPB FIN;
CLR ;
= #BUSY;
FIN: BE ;
END_FUNCTION_BLOCK
:Birnen(2) , Äpfel(1) , Zwetschken(3) .... usw. in eine bestimte Reihenfolge sortieren , man "benennt" die Objekten in die gewünschte Reihenfolge = "übersetzt" sie in INTEGER dann "radixsortiert" man sie und "übersetzt" die INTEGER zurück ...und ... hat man schon die Sortierung in der Gewünschte Reihenfolge das wäre sortieren nach Haupteigenschaft man kann aber genau so auch nach "Farbe" sortieren ( Rot(3), Grün(1) , Blau(2)...usw) ...oder nach Gewicht ( 12-15kg(3) , 23-44kg(2) , 129-1232kg(1)...usw)... man kann sogar willkürlich eine Sortierreihenfolge wählen (!) einzige Voraussetzung dafür wäre eine Bijektivität zwischen die INTEGER-ordnung und willkürlich gewählter Ordnung !
