Sortierbasutein mit Any Pointer

Zuviel Werbung?
-> Hier kostenlos registrieren
So, wie du das realisiert hast vergleichst du 2 Bytes mit einander und tauscht die aus (ggf.).
Wie steht das Ganze jetzt mit deinem 3-Byte-Gedanken vom Anfang in Verbindung und welcher Sinn steckt dahinter.

Außerdem ... ich kann in deinem Code-Beispiel keine Schleife und keine Pointer-Erhöhung erkennen ... Liegt aber vielleicht auch an meinem fortgeschrittenen Alter ...
 
hab das 3 byte vergleich... mal zur seite gelegt und fang mit etwas leichterem an...


also pointer erkennst du keinen >>>> L dbb[ar1,p#0.0] zb.


ja ich probier mal einen DB welcher mit 10 Byte Werten gefüllt ist zu sortieren


den code dazu habe ich ja schon gepostet funktioniert aber irgendwie nicth... (eigentlich 0)


lg steve
 
OK, mal ein Anfang,
nimms mir nicht übel, aber ich glaub du hast noch keinen blassen Schimmer von indirekter Adressierung. Ist ja auch nicht schlimm, jeder hat mal angefangen. Mach dich mal damit vertraut, und dann wird das schon.
kleines Beispiel:

Code:
L  dw#16#84000000
LAR1

auf [#DBin]

L  B [ar1, p#0.0]
L  B [ar1, p#1.0]
==I
...
Wär jetzt nur mal ein Beispiel wie das erste Byte mit dem zweiten verglichen werden kann, nur mal so als kleiner Anstoss. Aber wie gesagt erst mal mit dem Aufbau des Adressregisters und co vertraut...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Das mit dem DB-Aufruf und dem Register hat Steve schon richtig drin.
Mit dem Zeiger auf die erste Adresse hapert es aber dann schon.

Steve hat in seinem Code :
Code:
M002: LAR1 P##iStartadresse
So würde ich es nicht machen.
Start-Adresse ist ja warscheinlich die Nummer des ersten Bytes ...?

Also müßte es heissen :
Code:
L iStartadresse
ITD
T hPointer      // DWORD im TEMP-Bereich
 
LOOP: L hPointer
SLD 3
LAR1
Für den nächsten Durchlauf der Schleife :
Code:
L hPointer
L 3    // wegen der 3 Byte-Geschichte
+D
T hPointer
 
L hPointer
L #End_Adresse_Daten
<D
SPB Loop
Versuch das mal mit in deinen Code zu integrieren ...​
 
habs schon hinbekommen war nur ein paar kleine Fehler
zum Thema indirekte Adressierung.. kannte ich mich eigentlich für meine Verhältnisse ziemlich gut aus



L #iDB_Nr
T #tDb_Nr
L #iStartadresse
T #sStartadresse
U #iStart
FP #sm1
SPBN exit

AUF DB [#tDb_Nr] //Aufruf Daten DB
L #sStartadresse
M001: LAR1
SET
S #oSort_done
L #iAnz_Werte
L 1
-I
next: T #sCount //Schleifenzaehler
L DBB [AR1,P#0.0]
L DBB [AR1,P#1.0]
<=I
SPB M002
L DBB [AR1,P#0.0]
T #tTemp
L DBB [AR1,P#1.0]
T DBB [AR1,P#0.0]
L #tTemp
T DBB [AR1,P#1.0]
SET
R #oSort_done
SPB M002
M002: TAR1
L 8
+D
LAR1
L #sCount
LOOP next
UN #oSort_done
SPB M001
BE
exit: NOP 0

thx für eure Hilfe.....



 
Ok muss doch wieder mit anypointern arbeiten aber nicht zum vergleichen von Blöcken sondern nur zum schieben
ich soll dabei immer nur das erste Byte vom Block mit dem ertsen BYte vom 2ten Block vergleichen...

irgendjemand eine Idee??

code zum verschieben der Blöcke


Code:
CALL "BLKMOV" //Vergleichsblock1 Zwischenspeichern
SRCBLK :=#tVergleichsblock1
RET_VAL:=#tRetval
DSTBLK :=#tSaveBlock
 
CALL "BLKMOV" //Vergleichsblock2 in Vergleichsblock1 schieben
SRCBLK :=#tVergleichsblock2
RET_VAL:=#tRetval
DSTBLK :=#tVergleichsblock1
 
CALL "BLKMOV" //gespeicherten Vergleichsblock1 in Vergleiochsblock2 schieben
SRCBLK :=#tSaveBlock
RET_VAL:=#tRetval
DSTBLK :=#tVergleichsblock2
 
die beschreibung steht am anfang vom thread... der unterschied ist nur das ich nicht den gesamten block vergleiche und dann verschiebe sondern nur das erste byte im block mit dem ersten byte vom benachbarten Block und dann erst blockweise schiebe....


hier der Code für Byteweise sortierung mit Bubblesort
jedoch soll ich Blöcke vergleichen und entsprechend verschieben

Code:
  L     #iDB_Nr                     //DB Nummer einlesen
      T     #tDb_Nr                     //temp. speichern
      L     #iStartadresse              //Startadresse laden
      T     #sStartadresse              //statisch abspeichern
      L     #iSortierbereich            //Lade Sortierbereich
      T     #ssortierbereich            //statisch abspeichern
      L     P#1.0                       //Lade Bytebereich
      ==I                               //Vergleich ob Sortierbereich in BYTE
      U     #iStart                     //bei Start
      FP    #tsm1                       //pos. Flanke  Sortieren
      SPBN  exit
      AUF   DB [#tDb_Nr]                //Aufruf Daten DB
      L     #sStartadresse              //laden der Anfangsadresse
M001: LAR1  
      SET                               //Setze VKE 1
      S     #oSort_done                 //Setze Sortierung 1 Wert fertig
      L     #iAnz_Werte                 //Anzahl der Werte laden
      L     1                           // -1
      -I    
next: T     #sCount                     //Schleifenzaehler 
      L     DBB [AR1,P#0.0]             //Lade Vergleichsbyte 1
      L     DBB [AR1,P#1.0]             //Lade Vergleichsbyte 2
      <=I                               //Vergleichsyte 1 kleiner gleich Vergleichsbyte 2
      SPB   M002
      L     DBB [AR1,P#0.0]             //Lade Vergleichsbyte 1
      T     #tTemp                      //temp. abspeichern
      L     DBB [AR1,P#1.0]             //Lade Vergleichsbyte 2
      T     DBB [AR1,P#0.0]             //transferiere Wert in Vergleichsbyte 1
      L     #tTemp                      //Lade abgespeichertes Vergleichsbyte 1
      T     DBB [AR1,P#1.0]             //transferiere Wert in Vergleichsbyte 2 
      SET                               //Setze VKE 1
      R     #oSort_done                 //Rücksetze Sortierung 1 Wert fertig
      SPB   M002
M002: TAR1  
      L     P#1.0                       // addieren von 1 BYTE zur Adresse der Vergleichbytes
      +D    
      LAR1  
      L     #sCount                     //Schleifenzaehler laden
      LOOP  next
      UN    #oSort_done                 //Wenn Sortierung fuer 1 Wert nicht fertig
      SPB   M001
exit: NOP   0
 
Zuletzt bearbeitet:
AR1 auf erstes Byte Block1,
AR2 auf erstes Byte Block2,

nach einem Vergleichskriterium vergleichen,
dann verschieben / sortieren falls erfüllt oder nicht erfüllt.

Soll es so in etwa funktionieren?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
ja soweit so gut... die frage ist wie ich das mit dem Offset der ja variabel sein muss hinbekomme


zb .

L DBB[Ar1,P#0.0]
LDBB[Ar2,P#4.0]
<=I


die 4.0 also 4 byte versatz sollte ich über eine Variable einstellen können
 
ja soweit so gut... die frage ist wie ich das mit dem Offset der ja variabel sein muss hinbekomme
die 4.0 also 4 byte versatz sollte ich über eine Variable einstellen können

die einfachste möglichkeit die mir dazu einfällt:

Code:
      L     #variable1
      SLD   3
      LAR1  

      L     DBB [AR1,P#0.0]
      T     #vergleichswert1

      L     #variable2
      SLD   3
      LAR1  

      L     DBB [AR1,P#0.0]
      T     #vergleichswert2

      L     #vergleichswert1
      L     #vergleichswert2
      <=I
      ....
 
das klingt gut werd ich gliech mals ausprobiern aber wieso schiebst du das ganze um 3??

thx
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
wie der anypointer aussieht ist in der FAQ deutlich beschrieben.
der link dazu ist bereits gefallen.

für das tauschen der blöcke falls mehr als 1 dwort getauscht werden soll.
quellzeiger bauen
zielzeiger bauen

CALL SFC 20
SRCBLK := quellzeiger
RET_VAL:=
DSTBLK :=P#DB10.DBX 0.0 BYTE 8

CALL SFC 20
SRCBLK := zielzeiger
RET_VAL:=
DSTBLK :=P#DB10.DBX 8.0 BYTE 8

CALL SFC 20
SRCBLK := P#DB10.DBX 8.0 BYTE 8
RET_VAL:=
DSTBLK := quellzeiger

CALL SFC 20
SRCBLK := P#DB10.DBX 0.0 BYTE 8
RET_VAL:=
DSTBLK := zielzeiger
 
Any zeiger dazu hab ich mir dazu ja schon gebastelt

das ganze funktioniert mit einmal zwischenspeichern auch und verkürzt somit das programm

ist wert 1 gößer als wert 2 so wird werd i zwischengespeichert wert 2 in wert 1 geschoben und der zwischengespeicherte wert in wert 2....
 
komm mit meinem proggi nicht mehr weiter....


bisheriger code
Code:
      L     #iDB_Nr                     //DB Nummer einlesen
      T     #tDb_Nr                     //temp. speichern
      L     #iStartadresse              //Startadresse laden
      T     #sStartadresse              //statisch abspeichern
      L     #iBlockgroesse              //Lade Sortierbereich
      T     #sBlockgroesse              //statisch abspeichern
      L     #iSave_DB                   //Db Nummer Zwischenspeicher einlesen
      T     #sSave_DB                   //statisch abspeichern
      L     #sBlockgroesse              //Blockoffsteberechnung
      L     P#1.0
      *D    
      T     #tBlockoffset
      LAR1  P##tVergleichsblock1
      L     B#16#10                     //10h für s7
      T     LB [AR1,P#0.0]
      L     B#16#2                      //Typ BYTE
      T     LB [AR1,P#1.0]
      L     #sBlockgroesse              //Anzahl (Wiederholungsfaktor)
      T     LW [AR1,P#2.0]
      L     #tDb_Nr                     //Datenbaustein
      T     LW [AR1,P#4.0]
      L     #sStartadresse              //Startadresse des ersten Bytes
      SLD   3                           //Pointer bauen
      T     LD [AR1,P#6.0]              //Ergebnis in  Anypointer eintragen
      L     B#16#84                     //Speicherbereich (hier DB)
      T     LB [AR1,P#6.0]
      LAR1  P##tVergleichsblock2
      L     B#16#10                     //10h für s7
      T     LB [AR1,P#0.0]
      L     B#16#2                      //Typ BYTE
      T     LB [AR1,P#1.0]
      L     #sBlockgroesse              //Anzahl (Wiederholungsfaktor)
      T     LW [AR1,P#2.0]
      L     #tDb_Nr                     //Datenbaustein
      T     LW [AR1,P#4.0]
      L     #tBlockoffset               //Startadresse des ersten Bytes
      T     LD [AR1,P#6.0]              //Ergebnis in  Anypointer eintragen
      L     B#16#84                     //Speicherbereich (hier DB)
      T     LB [AR1,P#6.0]
      LAR1  P##tSaveBlock
      L     B#16#10                     //10h für s7
      T     LB [AR1,P#0.0]
      L     B#16#2                      //Typ BYTE
      T     LB [AR1,P#1.0]
      L     #sBlockgroesse              //Anzahl (Wiederholungsfaktor)
      T     LW [AR1,P#2.0]
      L     #sSave_DB                   //Datenbaustein
      T     LW [AR1,P#4.0]
      L     0                           //Startadresse des ersten Bytes
      T     LD [AR1,P#6.0]              //Ergebnis in  Anypointer eintragen
      L     B#16#84                     //Speicherbereich (DB)
      T     LB [AR1,P#6.0]
 
 
 
      U     #iStart                     //bei Start
      FP    #tsm1                       //pos. Flanke  Sortieren
      SPBN  M001
      AUF   "DB3 Sortierung"            //Aufruf Daten DB
      L     #sStartadresse              //laden der Anfangsadresse
M003: LAR1  
      SET                               //Setze VKE 1
      S     #oSort_done                 //Setze Sortierung 1 Wert fertig
      L     #iAnz_Werte                 //Anzahl der Werte laden
      L     1                           // -1
      -I    
M004: T     #sCount                     //Schleifenzaehler 
      AUF   "DB3 Sortierung"            //Auruf Sortier DB
      L     #sMD1                       //Adresse Vergleichsbyte 1
      T     #tMD1
      SLD   3
      LAR1  
      L     DBB [AR1,P#0.0]
      T     #sVergleichswert1
      L     #tMD2
      SLD   3
      LAR1  
      L     DBB [AR1,P#0.0]
      T     #sVergleichswert2
      L     #sVergleichswert1
      L     #sVergleichswert2
      <=I                               //Vergleichsyte 1 kleiner gleich Vergleichsbyte 2
      SPB   M002
      LAR1  P##tVergleichsblock1
      L     #tMD1                       //Speicherbereich (hier DB)
      T     LD     6                    //Ergebnis in  Anypointer eintragen
      LAR1  P##tVergleichsblock2
      L     #tMD2                       //Speicherbereich (hier DB)
      T     LD     6                    //Ergebnis in  Anypointer eintragen
 
      CALL  "BLKMOV"                    //Vergleichsblock1 zwischenspeichern 
       SRCBLK :=#tVergleichsblock1
       RET_VAL:=#tRetval
       DSTBLK :=#tSaveBlock
      CALL  "BLKMOV"                    //Vergleichsblock2 in Vergleichsblock1 schieben
       SRCBLK :=#tVergleichsblock2
       RET_VAL:=#tRetval
       DSTBLK :=#tVergleichsblock1
      CALL  "BLKMOV"                    //gespeicherten Vergleichsblock1 in Vergleiochsblock2 schieben
       SRCBLK :=#tSaveBlock
       RET_VAL:=#tRetval
       DSTBLK :=#tVergleichsblock2
      SET                               //Setze VKE 1
      R     #oSort_done                 //Rücksetze Sortierung 1 Wert fertig
      SPB   M002
M002: L     #tMD2                       //Vergleichsadresse 2 in Vergleichsadresse 1 transferieren
      T     #tMD1
      T     #sMD1
      L     #tMD2
      L     #sBlockoffset               //  addieren des Blockoffsets zur Adresse des Vergleichsblock2
      +D    
      T     #tMD2
      T     #sMD2
      L     #sCount                     //Schleifenzaehler laden
      LOOP  M004
      UN    #oSort_done                 //Wenn Sortierung fuer 1 Wert nicht fertig
      SPB   M003
M001: NOP   0
 
mit dem ursprünglichen problem ... ja damit hat es zu tun


also bsb hab einen speicher mit 10 byte


diese 10 byte teile ich ein in 5 blöcke
von diesen blöcken vergleiche ich jeweils das erste byte auf ihre größe und verschiebe dann mit blockmove die blöcke
 
:confused:
Ein Block ist 10 Byte groß und davon hast du 10 ...?
Ist das Byte_1 von Block_1 > Byte_1 von Block_2, dann tauscht du die beiden Blöcke ... so richtig verstanden ...?
Wenn ja, dann musst du erst Block_1 in einen Zwischen-Puffer schreiben, dann Block_2 in Block_1 und dann den Zwischenpuffer in Block_2 ...

Gruß
LL
 
Zurück
Oben