array inhalte verschieben

hellihjb

dann kannst du per shrd/shld ueber zwei 32bit register verschieben:

mov  eax,[di]
mov  edx,[di+4]
shrd eax,edx,8
shr  edx,8
mov  [di],eax
mov  [di+4],edx

input: 1,2,3,4,5,6,7,8
output: 2,3,4,5,6,7,8,0

Dragonslayer

könnte ich wenn ich nicht ausschließlich die 8086 register verwenden kann^^

Dragonslayer

mhm als ich hab mir da mal ne Schleife überlegt:

mov di, array         ;Pointer auf array
add di,07h            ;Auf Adresse der letzte Stelle des Array springen

VERSCHIEBEN:
mov ah,[di-1]         ;Inhalt von Adresse vor aktueller Position in Ah laden
mov byte [di], ah          ; Inhalt in aktuelle Adresse laden
dec di                ; Eine Adresse "zurückspringen" im Array
cmp di,array          ;Pointer mit Adresse von [array + 0] vergleichen
JNE VERSCHIEBEN       ;Wenn erste Stelle des Arrays noch nicht erreicht zum Anfang

mov [di],al          ;Inhalt von al in erste Stelle des Arrays laden 
                     ;al beinhaltet ne Eingegebene Hex-Ziffer

Wo ich mir noch nicht sicher bin ist diese vergleichsbedingung vergleicht man so wirklich mit der Startadresse des arrays, und macht die Schleife so überhaupt sinn oder hab ich da irgend nen bösen denkfehler?

Außerdem hab ich noch weitere Schleife in der irgendwo nen dummer Fehler drinnen zu sein Scheint.
Die Schleife soll den Inhalt des Arrays auf Display ausgeben.
Das Problem ist es wird nur immer die selbe Stelle des Arrays ausgegeben und ich weis nicht genau warum.

Ich sollte vielleicht kurz auf den Interupt eingehen in der Schleife, damit klar wird warum ich bestimmte bytes in den Registern Setze.

INT 6, Funktion 4 - Ausgabe eines Hex-Bytes
Aufruf:
       AH=04
       Hex-Byte in BL
       Anzeige ab Displaystelle DL
Ergebnis: Ausgabe

Die Schleife:

EINGABE:
       mov ah, 04h     ; Funktionsaufruf 4 für die verwendung von int6
       mov dl, 01h     ; Erste Displaystelle laden

       AUSGABE_ARRAY: 
       mov di,array     ;Pointer auf Anfangsadresse des array
       mov bl, [di]     ; Inhalt der aktuellen Array stelle zur Ausgabe in bl
       int 6            ;Ausgabe
       inc di           ;auf nächste array stelle "springen"
       inc dl           ;nächste Displaystelle wählen
       cmp dl,08h        ;Vergleich ob letzte Zifferstelle erreicht
       jBE AUSGABE_ARRAY          ; solange Kleiner-gleich als Zifferstelle Schleife wiederhohlen

Also ich bin grad echt ratlos warum der inhalt von [array +0] auf allen displaystellen ausgegeben wird...

Nobuo T

Dragonslayer schrieb:

mhm als ich hab mir da mal ne Schleife überlegt:

mov di, array         ;Pointer auf array
add di,07h            ;Auf Adresse der letzte Stelle des Array springen

VERSCHIEBEN:
mov ah,[di-1]         ;Inhalt von Adresse vor aktueller Position in Ah laden
mov byte [di], ah          ; Inhalt in aktuelle Adresse laden
dec di                ; Eine Adresse "zurückspringen" im Array
cmp di,array          ;Pointer mit Adresse von [array + 0] vergleichen
JNE VERSCHIEBEN       ;Wenn erste Stelle des Arrays noch nicht erreicht zum Anfang

mov [di],al          ;Inhalt von al in erste Stelle des Arrays laden 
                     ;al beinhaltet ne Eingegebene Hex-Ziffer

Wo ich mir noch nicht sicher bin ist diese vergleichsbedingung vergleicht man so wirklich mit der Startadresse des arrays, und macht die Schleife so überhaupt sinn oder hab ich da irgend nen bösen denkfehler?

Wesentlich mehr Sinn, als dein erster Entwurf, bei dem ich mich irgendwie frage, wie du darauf gekommen bist. :p
Das "add di,7" kannst du auch weglassen, wenn du gleich 7 zum Offset addierst.
Also "mov di, array + 7"
Das funktioniert, weil das Offset "array" hier letztendlich auch nur eine Konstante ist.
Die Abbruchbedingung der Schleife kannst du so machen. Natuerlich gibt es noch 1001 andere Moeglichkeiten, aber so ist das schon ok.

Dragonslayer schrieb:

Außerdem hab ich noch weitere Schleife in der irgendwo nen dummer Fehler drinnen zu sein Scheint.
Die Schleife soll den Inhalt des Arrays auf Display ausgeben.
Das Problem ist es wird nur immer die selbe Stelle des Arrays ausgegeben und ich weis nicht genau warum.

Dazu nur der Hinweis, dass der Fehler wirklich sehr offensichtlich ist. Nur 2 Zeilen vertauscht.
Schlaf vielleicht mal drueber, und schau dir die Sache morgen nochmal an.
Du koenntest hier allerdings die Abbruchbedingung der Schleife eleganter gestalten, wenn du dl von 8 runterzaehlst (entsprechend musst du mit dem Array dann halt auch von hinten anfangen). Der Befehl "dec" setzt naemlich uA. das Z(zero)-Flag, wenn dl 0 wird. Das kannst du mit den Befehlen j(n)e (bzw. aequivalent j(n)z) abfragen.

Dragonslayer

ach verdammt natürlich ich lade zu beginn jeder schleife wieder die anfangsadrese, da bringt mir dann ja auch das inkrementieren nichts.

Also einfach

mov di,array     ;Pointer auf Anfangsadresse des array

vor die schleife setzen

edit:
Hm ich hab das gerade mal getestet jetzt wird die erste Ziffer ausgegeben und die restlchen ziffern die auf den andern segmenten ausgegeben werden sind komischerweise
9 A B C D E F

komisch die müssten ja eigentlich 0 sein weil ich in den anderen stellen des arrays doch zu beginn noch nichts reingeschrieben habe

Nobuo T schrieb:

Du koenntest hier allerdings die Abbruchbedingung der Schleife eleganter gestalten, wenn du dl von 8 runterzaehlst (entsprechend musst du mit dem Array dann halt auch von hinten anfangen). Der Befehl "dec" setzt naemlich uA. das Z(zero)-Flag, wenn dl 0 wird. Das kannst du mit den Befehlen j(n)e (bzw. aequivalent j(n)z) abfragen.

Hm das klingt vernünftig nur gibt es da einen haken

das problem ist mein Interupt gibt
ein Hexbyte AB der displaystelle xy aus und es werden immer 2 displaystellen beschrieben, da es sich um ein Byte und damit 2 hexziffern handelt.

Ich schreibe jetzt auf dem Display von Rechts nach links

angenommen im array steht:

[array 0]=0A
[array 1]=0B
[array 2]=0C
[array 3]=0D
[array 4]=0E
[array 5]=0F
[array 6]=01
[array 7]=02

Das Display sieht wie folgt aus

DL: 08 07 06 05 04 03 02 01

nun wir das nacheinander wie folgt beschrieben

                  0H AH      [array + 0]
08 07 06 05 04 03 02 01

dann wir 0H im nächsten schritt überschrieben:

               0H BH AH      [array + 1] dazu
08 07 06 05 04 03 02 01

Wenn ich jetzt von 08 nach 00 runterzähle dann müssten ja nur die oberen 4 bits also 0h dargestellt werden und die unteren überschrieben, was ziemlich sinnfrei in diesm fall wäre...

hellihjb

man kann aus deiner beschreibung nur wage erahnen was du willst.
ich *glaube* du moechtest dein byte als zwei hexziffern ausgeben?
benutze doch einfach eine kleine tabelle um jeweils 4bit in eine hexziffer zu konvertieren:

db int2hex '0123456789ABCDEF'

mov si,int2hex ; zeiger auf tabelle
xor bx,bx      ; bx= 0

mov bl,[di]    ; byte auslesen
shr bl,4       ; die oberen 4bit (0..15)
and bl,15      ; *bzw* die unteren 4bit

mov bl,[si+bx] ; 0..15 -> '0'..'F'
int 6          ; zeichen ausgeben

Dragonslayer

oh ich hab auch gesehen warum ich hab da ein bischen zuviel zitiert in meinem letzten post, jetzt sollte es mehr sinn ergeben.

Es ging mir nur darum das ich noch einen Bug in den Schleifen habe zumindest dachte ich das.

Ich hab die routine gerade mal getestet und sie funktioniert nun auch komischerweise nur korrekt auf dem SBC-86 mikrokontroller, nicht in der simulation, da tritt immer noch diese merkwürde ausgabe auf wie im letzten post beschrieben.

Ich hätte da noch ne Frage.
Gib es ne komfortable möglichkeit den gesammten Array in halt 0 zu setzen oder muß ich da ne schleife bauen die das macht?

mov byte [array] ,0h
mov byte [array + 1] ,0h
mov byte [array + 2] ,0h
mov byte [array + 3] ,0h
mov byte [array + 4] ,0h
mov byte [array + 5] ,0h
mov byte [array + 6] ,0h
mov byte [array + 7] ,0h

weil man kann ja auch zu beginn alle inhalte mit

array times 8 db 0

Ist da nen ähnlicher Befehl zur laufzeit verfügbar?

Nobuo T

Dragonslayer schrieb:

[...]
weil man kann ja auch zu beginn alle inhalte mit
array times 8 db 0
Ist da nen ähnlicher Befehl zur laufzeit verfügbar?

Nein. Aber wenn du an jede 2. Adresse ein Word statt ein Byte schreibst, kannst du die Anzahl deiner movs einfach halbieren.
Fuer groessere Arrays nimmt man sonst idR. einfach stos.

Dragonslayer

könnte man dann nicht auch einfach an jede 4te adresse ein doppelword schreiben oder ist das nicht zulässig?
weil ich mein kann ja auch double word , quad word und tenbyte variablen definieren, kann man solche größen auch zur laufzeit kopieren oder ist das irgendwie wegen der registergröße an word gebunden?

Dragonslayer

Kann es sein das in dem kopier algothymuß noch irgendwo nen fehler liegt?
In meiner simulation zerhauts mir regelmäßig den inhalt des arrays.
Ich hab komischerweise danach drinnen stehen:

[array + 0] = eingegebene wert / soweit richtig
[array + 1] = ne 2 stellige hex zahl zb 36
[array + 2] = 37
[array + 3] = 38

usw.

ich frag mich woran das liegen kann?

edit: könnte es sein das ich nicht den inhalt einer adresse sondern die adresse selber rein kopiere?

das komische ist ja im simulator läufts schief aber auf dem mikro controller funktioniert der algorithmuß

mov di, array + 7        ;Pointer auf array

VERSCHIEBEN:
mov ah,[di-1]         ;Inhalt von Adresse vor aktueller Position in Ah laden
mov byte [di], ah          ; Inhalt in aktuelle Adresse laden
dec di                ; Eine Adresse "zurückspringen" im Array
cmp di,array          ;Pointer mit Adresse von [array + 0] vergleichen
JNE VERSCHIEBEN       ;Wenn erste Stelle des Arrays noch nicht erreicht zum Anfang

mov [di],al          ;Inhalt von al in erste Stelle des Arrays laden
                     ;al beinhaltet ne Eingegebene Hex-Ziffer