Hi, auf die Gefahr hin, dass Ihr mich jetzt zerfleischt - Ich finde wirklich nichts !!! Frage: Wie kann ich aus einem Register einen Wert im SRAM ablegen zur Zwischenspeicherung. Ich suche so eine Art push/pop ins RAM ... Gruß Uboot-Stocki
Ich weiß ja nicht, welchen Controller Du benutzt, aber bei meinem 2313 gibt es push und pop, wie beim x86 auch... Aber meistens dürften doch die Register ausreichen, oder?
@UBoot-Stocki Klar kann dein TINY26 push und pop wie alle AVR mit internem SRAM. Steht auch auf Seite 127 des Datenblattes. Nähere Erläuterungen zu den Befehlen findest du im AVR Instruction Set.
Hallo, ich habe die Frage ein wenig anders verstanden als meine beiden Vorredner. Push Pop ist sehr wohl bekannt aber du willst einen Registerinhalt an eine bestimmte Speicherstelle im RAM ablegen, oder ? Wenn Du ihn von dort aber nur wieder wegpopst gibt es wohl keinen Grund nicht den Stack zu verwenden. Oder liege ich da jetzt falsch ? Bitte die Frage noch ein wenig konkretisieren :D Gruß Main666
@main666 dann wird's ja noch simpler, dafür gibt's ja die Befehle sts und lds.
Ähm, dass es die Befehle push und pop für den Stack gibt ist klar. Ich möchte eine Art Applikationsstack implementieren. Den normalen Stack kann ich nicht verwenden weil dort ja auch Rücksprungadressen abgelegt werden. In einem Unterprogramm würden daher die im Hauptprogramm abgelegten Werte nicht mehr zugreifbar sein. Daher die Idee mit dem Applikationsstack. Nur wie ? @Johannes: Also ich habe desöferen das Problem, daß meine Register nicht ausreichen bzw. ich "Klimmzüge" machen muss damit sie reichen. @Mikki: sts/lds: Sind wohl die Befehle. Nur wo kann man da hin speichern ohne was (z.B. den Stack) kaputt zu machen ??? Zu Controllern: Ich Arbeite am liebsten mit ATTiny26 weil der keine externen Bauteile braucht - Manchmal auch mit 90S4433 bzw. jetzt Mega8 Gruß und Danke für die Geduld mit meiner unpräziser Frage :-) Uboot-Stocki
Einen eigenen Applikations-Stack kannst du z.B. mit den Index-Registernpaaren X,Y,Z verwalten. Wenn es allerdings nur darum geht ein paar Werte zu speichern dan reicht auch die Kombination LDS/STS und man benutzt die unteren Adressen ab $60 der SRAM, der Stack wächst ja vom oberen RAM Ende nach unten.
Hi,
das habe ich nicht verstanden. Mit dem Befehl ST kann ich (abh. vom
"Zeiger" in Z) in das RAM schreiben, das ist klar.
Im Programm ist der Stack mit:
ldi temp, RAMEND
out SPL, temp
auf das RAM-Ende festelegt. Der 4433 hat m.E. 255 Byte RAM, d.h. der
Stackpointer steht bei $FF und wird kleiner - Auch klar.
Aber warum soll ich dann bei $60 anfangen ? Naiver Weise hätte ich bei
$00 begonnen ... ?!?!
Gruß
Uboot-Stocki
Der 4433 hat genau wie der TINY26 128 Byte SRAM. An Adresse 00-1F hex liegen die Register R0-R31 gefolgt vom I/O-Bereich 20-5F hex. bei einigen größeren MEGAs 162/64/128 geht dieser Bereich bis FF hex. Darauf folgt dann das interne SRAM welches somit bei 60 bzw. 100 hex. beginnt.
und der Sinn der Sache ist, möglichst viel im RAM unterbringen zu können. Datenadressen wachsen von unten (Anfang des RAMs) nach oben, der Stack vom RAM-Ende nach unten. Man kann auf diese Weise den gesamten RAM nutzen, aber aufpassen: läuft der SP in den Datenbereich, gibts Salat. Geschützte Speicherbereiche gibt es nicht, auch kann kein Compiler oder Assembler erkennen, ob da ein Konflikt lauert. Einfach die max. Aufruftiefe von Unterprogrammen incl evtl. push, dazu dann noch die ISR (falls nicht verschachtelt, dann kommen die anderen ISR auch noch dazu), die die meisten push benutzt, dann hast du die max. Stacktiefe und damit weißt du, wieweit du den RAM für Datenspeicherung benutzen darfst. In der Simulation sind sog. stack-end-marker recht nützlich, da sieht man dann, wie tief der SP tatsächlich mal gekommen ist.
Ähmm,
wer lesen kann ist klar im Vorteil ... Tatsächlich haben der 4433 und
der Tiny26 nur 128 Byte RAM. Dass die Register 0-31 im RAM liegen hätte
mir eigentlich klar sein müssen :-] Der IO ist ebenfass dahin gemapped
... Somit ist auch klar, warum ich bei $60 = 96 anfangen muß. Somit
bleiben 32 Byte für meine Daten ("Applikationsstack") und den
Controller-Stack.
Da wird es schon ganz schön eng ... Werde mal damit "rumspielen" ...
Nur so am Rande: Wie kompliziert ist es eigenlich was ins EEPROM zu
schreiben ? Das könnte mit für Programmkonstanten/Parameter ja auch
schon weiterhelfen ?!?!?
Gruß
UBoot-Stocki
Hi @ UBoot-Stocki, warum bleiben dann mur 32byte? dein Ram fängt bei $0060 an, und geht bis $0060+128, somit hast du 128 byte frei nutzbaren Ram. Du musst halt nur auf den Stack aufpassen damit du nicht in den Datenbereich kommst oder, dazu kannst du dir ja ne Adreese anlegen wo du dir merkst wo du im Ram aktuell bist und vergleichst diese mit deinem SP. Wenn SP und Ram gleich sind oder fast gleich, musst du dir nur ne Exception bedingung aussuchen ... vielleicht einen Reset des µC? Um die x,y,Z Pointer nicht zu verschwenden würde ich mir die ersten 2-8byte fest für einen Parameter Stack vergeben (startadresse ,endadresse,pointer),.. es ist übrigens ne gute möglichkeit um an subroutinen mit einem Parameter Stak daten zu übergeben. MfG Sebastian PS: es ist ja irrsinn alle 32 register immer sichern zu wollen,.. arbeitest du vielleicht bei MS?
.. noch was vergessen,.. das ee is sehr einfach zu lesen bzw.
schreiben,.. fast einfacher als diese ganze ADC geschiche,.. siehe
Codesammlung oder Atmel Appnotes. Da findest du genug beispiele.
;************************************************************
;* FUNCTION
;* EE_write
;* DESCRIPTION
;* Write to every address in the EEPROM and
EE_write:
sbic EECR,1 ;EEWE
rjmp EE_write ;waits until EEPROM ready
out EEARH,YH ;outputs address high
out EEARL,YL ;output address low
out EEDR,temp0 ;outputs data
sbi EECR,2 ;EEPROM Master Write Enable( EEMWE)
sbi EECR,1 ;EEPROM Write Enable(EEWE)
ret
EE_write_1:
sbic EECR,1 ;EEWE
rjmp EE_write_1 ;waits until EEPROM ready
out EEARH,YH ;outputs address high
out EEARL,YL ;output address low
out EEDR,temp1 ;outputs data
sbi EECR,2 ;EEPROM Master Write Enable( EEMWE)
sbi EECR,1 ;EEPROM Write Enable(EEWE)
ret
;************************************************************
;************************************************************
;************************************************************
;* FUNCTION
;* EE_read
;* DESCRIPTION
;* Reads the EEPROM and test's that data equals adress
EE_read:
sbic EECR,1 ;skip if EEWE clear
rjmp EE_read ;Waits until EEPROM ready
out EEARH,YH ;output address high
out EEARL,YL ;output address low
sbi EECR,0 ;set EERE (Read-strobe)
in temp0,EEDR ;inputs data
ret
EE_read_1:
sbic EECR,1 ;skip if EEWE clear
rjmp EE_read_1 ;Waits until EEPROM ready
out EEARH,YH ;output address high
out EEARL,YL ;output address low
sbi EECR,0 ;set EERE (Read-strobe)
in temp1,EEDR ;inputs data
ret
;************************************************************
Hi Sebastian, "es ist übrigens ne gute möglichkeit um an subroutinen mit einem Parameter Stak daten zu übergeben." Genau darum geht es. Ich habe ein Unterprogramm, welches verschiedene Parametrisierungen braucht. Diese möchte ich im RAM ablegen um Register zu sparen ... Ich arbeite nicht bei MS. Bin ich deshalb gar nicht auf die Idee gekommen, alle Register im RAM zu sichern? Gruß UBoot-Stocki
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.