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?

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.

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

De laatste instructie is niet correct, komt niet overeen met de C-code.

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 :P

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?

AVR assembler doet wel aan two complements. Hebben we in de les gehad :)

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?

Welke listing gebruik je om dat resultaat te bereiken, jou eigen of die van KaRaMBa?

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