Beste,
Voor school hebben we de opdracht een C programma na te maken in assembly. Nu heb ik al het een en ander geprobeerd en ben ik benieuwd of ik op de goeie weg ben. Zou verder niet weten hoe ik de wil doe die checkt of a > 0.
Gaat hierbij om de ATmega32
Gr
/*
int a = 3;
int b = 7;
int c;
do {
a = a-1;
b = b-1;
c = a;
if (b == 6) {
b = b-a;
} else {
if (b == 3) {
a = a-1;
}
}
} while (a > 0);
a=0,b=3,c=1
*/
.include "m32def.inc"
.dseg
.def inta = r16
.def intb = r17
.def intc = r18
.cseg
LDI inta,3
LDI intb,7
LOOP:
DEC inta
DEC intb
MOV intc,inta
CPI intb,6
BREQ BISA
BRNE BNOTA
BISA:
//b = b-a;
SUB intb,inta
ret
BNOTA:
cpi intb,3
DEC
Ik heb niet direct een idee wat voor 'n assembly dit is, maar enkele vragen om je op weg te helpen:
Wat doet de CPI instructie PRECIES? (bijv. welke status flaggen worden er gezet)
Zijn er andere instucties die status flaggen zetten?
Je gebruikt al BREQ en BRNE. Wat zijn de andere (conditionle) branch instructies? En wanneer jumpen die?
Edit: Oh, en ik zie dat je RET gebruikt: wat doet die instructie? (m.a.w. waarom gebruik je hem daar?)
[Bericht gewijzigd door KaRaMBa op (13%)]
Hier is de datasheet van de ATmega32. Instructie set begint op pagina329
CPI vergelijkt een register met een waarde.
Bijv CPI r17,8
BREQ = branch if equal
BRNE = branch if not equal
RET is return, ik wou dat hij nadat register a bij b afgetrokken was gereturnd werd naar de loop.
Status flaggen? Geen idee wat dat zijn eigenlijk?
[Bericht gewijzigd door Workerbee op (20%)]
Status flaggen? Geen idee wat dat zijn eigenlijk?
Daar was ik al bang voor 
CPI vergelijkt een register met een waarde.
En dan? Met alleen vergelijken ben je er natuurlijk niet
BREQ = branch if equal
BRNE = branch if not equal
Als wat (not) equal is?
As je weet hoe de instructies werken, ben je al bijna klaar 
edit: ik heb het instructie-overzicht er eens bijgepakt. Ziet er handig, overzichtelijk en compact uit! Ideaal!
Je kan precies zien wat bijv de CPI instructie doet (Operation kolom), welke flaggen er aangepast worden (Flags kolom), en welke flaggen er van invloed zijn bij de diverse BRanche instructies (Description en Operation kolom)
[Bericht gewijzigd door KaRaMBa op (31%)]
Ah dus als ik het goed begrijp. Je doet een compare, deze checkt of je register een waarde {x} heeft. Daarna zet hij een status flag die je kan checken met een branch instructie. Begrijp ik dit goed?
Druiloor
Opgepast: MaartenBakker citaat: "ruik ik een troll die per ongeluk met de arreslee meegelift is" :
Ja, dat begrijp je goed
brne springt weg als de resultaten niet eq zijn
direct daarachter breq plaatsen werkt wel, maar is niet fraai, het is immers daar ALTIJD equal.
ret is fout gebruikt. en tot slot loop je op de laatste regel er niet uit als a=0.
Nakijken dus wat statusvlaggen zijn (SREG) en het subroutinemechanisme met stack.
Als je dat begrepen hebt kun je nog nalopen dat
dec a
mov of ld of lds
breq
werkt omdat de mov of ld of lds de statusvlaggen niet beinvloedt, die van dec a zijn dus nog geldig.
dec a is wel een vervelende instructie want de Z vlag wordt wel gezet maar de carry niet als hij onder 0 duikt.
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Wat statusflags zijn moet je toch wel weten als je met controllers werkt...
(zero, carry, half-carry...)
Als het alleen om > 0 gaat, kun je TST gebruiken (en dan N en Z flag testen)
Je kunt ook SUB, EOR en andere instructies gebruiken...
Op 6 maart 2013 14:42:50 schreef Workerbee:
Ah dus als ik het goed begrijp. Je doet een compare, deze checkt of je register een waarde {x} heeft. Daarna zet hij een status flag die je kan checken met een branch instructie. Begrijp ik dit goed?
Om precies te zijn doet een CPI "Rd - K": een substractie zonder het resultaat op te slaan. Het zal echter wel de flaggen zetten, die normaal bij een substractie gezet zouden worden. En die flaggen kun je inderdaad weer gebruiken bij een conditionele branch.
Oke, begrijp het grotendeels denk ik.
Nieuwe code geschreven en benieuwd of ik op de goede weg ben.
.include "m32def.inc"
.def inta = r16
.def intb = r17
.def intc = r18
.def stck = r19
init:
LDI inta,3
LDI intb,7
; opzetten stack pointer (nodig voor rcall)
LDI stck, LOW(RAMEND)
OUT SPL, stck
LDI stck, HIGH(RAMEND)
OUT SPH, stck
main:
RCALL loop
//zodra er gereturned word is de while loop afgelopen
//en dan hier het programma "levend" houden
lus: rjmp lus
loop:
TST inta
//Als de status register bits(Z) niet gezet zijn gaan we door
BRNE continue
ret
continue:
DEC inta
DEC intb
MOV intc,inta
CPI intb,6
//Hier weer SREG CHECKEN
Hoe kan het dat hij elke keer opnieuw de waarders inlaad en hoe kan ik dit voorkomen. Nu gaat er een waarde af in het register en door de LDI word hij na 1x door het programme te lopen weer zijn oude waarde.
[Bericht gewijzigd door Henry S. op (13%)]
Waarom wil je eigenlijk met rcall aan de slag? in het C programma staan ook geen functie-aanroepen. Het kan prima zonder, en maakt het wellicht voor een beginner makkelijker.
Helpt het om het C programma wat te herschrijven?
[code=C]
int a = 3;
int b = 7;
int c;
loop:
a = a-1;
b = b-1;
c = a;
if (b == 6) {
b = b-a;
} else {
if (b == 3) {
a = a-1;
}
}
if(a > 0) {
goto loop;
}
[/code]
Zoeits word het dan?
.include "m32def.inc"
.def inta = r16
.def intb = r17
.def intc = r18
.def stck = r19
init:
LDI inta,3
LDI intb,7
loop:
DEC inta;
DEC intb;
mov intc,inta
CPI intb,6
BREQ beq
CPI intb,3
BREQ bea
TST inta
BREQ loop
beq:
SUB intb,inta
JMP loop
bea:
DEC inta
JMP loop
Je bent er bijna, maar je 'flow' is nog nog iets anders. Waar moet het programma verder gaan na beq of bea? (hint: niet bij loop)
Oke, heb het nu zo en het werkt:
loop:
DEC inta
DEC intb
mov intc,inta
CPI intb,6
BREQ beq
CPI intb,3
BREQ bea
beq:
SUB intb,inta
JMP loop
bea:
DEC inta
TST inta
BREQ loop
De TST kijkt hierbij of inta > 0 als dit niet het geval is zet je de Z flag. De BREQ kijkt of deze flag gezet is, zo ja skip de code die erna komt. Gebeurd er nu ook nog wat nadat het programma "afgelopen" is?
Op 6 maart 2013 18:53:00 schreef Workerbee:
Oke, heb het nu zo en het werkt:
loop:
DEC inta
DEC intb
mov intc,inta
CPI intb,6
BREQ beq
CPI intb,3
BREQ bea
// wat gebeurt er hier als b niet 6 en niet 3 is?
beq:
SUB intb,inta
JMP loop // moeten we hier altijd terug naar loop?
bea:
DEC inta
TST inta
BREQ loop
Ik zie toch nog twee fouten, hoor.
Gebeurd er nu ook nog wat nadat het programma "afgelopen" is?
Mja, je AtMega weet niet dat het programma is afgelopen
Wat er zal gebeuren is dat je uC door zal gaan met het uitvoeren van de instructies die toevalligerwijs nog in het geheugen aanwezig zijn na je programma.
Maar aangezien het hier een (theoretische) schoolvraag betreft, denk ik niet dat je daar rekening mee hoeft te houden.
Klopt was pure interesse 
Er gebeurd toch niks als b niet gelijk is aan 6 of 3? Of word er dan weer gesprongen naar de loop:?
En bij beq nog een check of er sreg is geset?
Er wordt inderdaad niet gesprongen als b niet gelijk is aan 6 of 3: de code loopt dus gewoon door zonder te springen, rechtstreeks het stukje onder "beq:" in
Begin er minder van te snappen geloof ik.
Zo is hij nog niet goed?
loop:
DEC inta
DEC intb
mov intc,inta
CPI intb,6
BREQ beq
CPI intb,3
BREQ bea
JMP loop
// wat gebeurt er hier als b niet 6 en niet 3 is?
beq:
SUB intb,inta
TST intb
BREQ loop
bea:
DEC inta
TST inta
BREQ loop
Uhm, bijna, maar nu heb je weer een nieuwe fout erbij 
Ik denk dat het een beetje een bomen-bos verhaal aan het worden is. Ik zou het zo doen:
init:
LDI inta,3 // a = 3
LDI intb,7 // b = 7
loop:
DEC inta; // a = a - 1
DEC intb; // b = b - 1
mov intc,inta // c = a
CPI intb,6 // if(b == 6)
BREQ beq // goto beq
CPI intb,3 // if(b == 3)
BREQ bea // goto bea
check:
TST inta // if(a != 0)
BRNEQ loop // goto loop
JMP done // exit();
beq:
SUB intb, inta // b = b - a
JMP check // goto check
bea:
DEC inta // a = a - 1
JMP check // goto check
done:
JMP done
Disclaimer: ik heb voor vanmiddag nog nooit iets met AVR assembly gedaan. Syntax is afgeleidt uit wat ik uit dit topic heb geleerd
Volgens mij is de while-test niet correct.
Op 6 maart 2013 21:18:58 schreef KaRaMBa:
check: TST inta // if(a != 0) BRNEQ loop // goto loop
Die test of a = 0, niet of a > 0, of doet een AVR assembler niet aan two's complements?
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Test voor a > 0:
check:
TST inta //
BRBS 2,loop // (N)egative
BRBS 1,loop // (Z)ero
... // Inta > 0
...
Oke super!
Je test met BRBS 2 nog op negatief omdat het two complements is dus.
Het resultaat van de register is het volgende:
inta 0x02
intb 0x04
intc 0x02
Terwijl het resultaat in C is:
a=0,b=3,c=1
Hoe kan dit? Zie ik nog wat over het hoofd?
roadrunner84
Meep! Meep!
Dat resultaat komt toch precies overeen met de C code uit de startpost?
stappen schema
A B C
2 4 2 (start)
1 3 1 (a = a - 1, b = b - 1, c = a)
0 3 1 (b == 3 ==> a = a - 1)
Never mind