LDS und der Stackpointer

[Läubi .. (laeubi)]

Also wenn ich folgenden Befehl verwende:

lds r17, SPL;

lädt er dann die Daten auf die der Stackpointer gerade zeigt in Register 
17?
Ich interpretiere zumindest so das Datenblatt so:
LDS Rd, k Load Direct from SRAM Rd ← (k)
Oder lädt er dann von Adresse (0x3d) also der Andresse in der .def 
datei??
Irgendwie ist mir das nicht ganz klar.

[Michael U. (Gast)]

Hallo,

Deine 2. Annahme ist richtig, er holt den Wert aus SPL

(k) ist eine 16Bit-Speicheradresse, SPL ist eine Assemblervereinbarung, 
es wird also SPL durch den Wert der Zuweisung in der .def ersetzt.

Was Du mit 1. meinst, wäre wohl indirekt indizierte Adressierung, die 
kann der AVR nicht, indirekt kann er, ld r17,Z  als Beispiel.

Gruß aus Berlin
Michael

[Joerg X. (Gast)]

es passiert zweiteres (mit "direct" ist bei Speicheraddressierung 
gemeint, dass der Befehl selbst die Adresse enthält - lds, sts brachen 
beim AVR auch 32Bit statt 16)
wenn du an die Daten kommen willst, auf die der Stackpointer zeigt nimm 
"pop", oder kopier den Stackpointer in einen anderen Pointer (X, Y, Z) 
und nimm "ld", aber ob das sinn ergibt?!

[Läubi .. (laeubi)]

Naja wenn man z.B. Variablen vor einem Funktionsaufruf auf den Stack 
schiebt will man sie danach vieleicht auch wieder lesen :)
Klar geht das mit pop ebenso. aber ich dachte mir das es vieleicht über 
den Stackpointer ne direkte möglichkeit gibt.

[Joerg X. (Gast)]

du musst bei 32 Registern noch Daten über den Stack übergeben ?
sonst evtl. die Rückkehraddresse und die Daten 'poppen' und 
anschließend die Addresse (vom R/CALL) wieder 'push'en (man könnte auch 
mit IJMP zurückkehren, aber ....)

[Thomas (kosmos)]

mit lds und sts kanst du direkt deine Werte ins SRAM legen, mit pop und 
push geschied das ja nur Stapelweise also "first in last out". Ich nutze 
das bei mir so so muss ich mir um die genaue Speicheradresse im SRAM 
keine Gedanken machen, nur zum nem Stack Überlauf darf es halt nicht 
kommen.

.include "tn26def.inc"
.def  temp  =R16
.def  temp2  =R17
.def  temp3  =R18
.def  temp4  =R19

.DSEG  ;Reserve jeweils 1 Byte / Variable eim SRAM
Wert1:  .byte  1
Wert2:  .byte  1
Wert3:  .byte  1
Wert4:  .byte  1

.cseg
....
....
lds temp, Wert1  ;Lade Wert aus SRAM ins temp Register
rol temp
sts Wert2, temp ;Speichere Wert aus temp Register ins SRAM an andere 
Adresse

[Läubi .. (laeubi)]

naja das MUß ich nicht würds aber gern mal probieren ;)
jeder PC regelt so die Variablenübergabe...

[Joerg X. (Gast)]

>jeder PC regelt so die Variablenübergabe...
aber nur (noch) wenn's nötig ist, die x86 (genauer IA-32 oder AMD64) 
haben auch genug register, aber normalerweise ist das Compilerabhängig

[Joerg W. (joergwolfram)]

Ich mache das zum Beispiel so ähnlich , um feste nullterminierte Texte 
aus dem Flash auf LCD/Bildschirm auszugeben. Die Routine wird dadurch 
zwar etwas aufwändiger, der Aufruf dafür um so einfacher.

outtext:    pop ZH        ;Rücksprungadresse vom Stack holen
            pop ZL
            lsl ZL        ;*2 da wir Bytes wollen
            rol ZL
            ...           ;Daten über Z+ lesen, bei 0x00 abbrechen
            lsr ZL        ;/2 da Befehle wortweise organisiert sind
            rol ZH
            ijmp          ;Rücksprung

Um jetzt einen Text auszugeben, reicht folgender Aufruf:

            rcall outtext
            .db "Hallo Welt",0x00

Falls sich eine ungerade Anzahl an Bytes ergibt, wird das normalerweise 
vom Assembler (ich benutze avra) mit 0x00 aufgefüllt.

Eine Parameterübergabe über den Stack ist auch möglich, ich finde es 
aber besser, dafür einen eigenen Stack über eines der drei Indexregister 
X,Y,Z einzurichten, da man auf diese Weise auch leichter feststellen 
kann, wieviele Parameter auf dem Stack abgelegt wurden.

Gruß Jörg