Color:
ldr r2, =color
ldr r3, [r2]
add r3, r3, #0x80
str r3, [r2]
bx lr
str r2,[r0,#8]!
delay:
mov r0,#0x1F00
delayLoop:
subs r0,r0,#1
bne delayLoop
bx lr
.data
x: .byte 200
y: .byte 21
.align 4
color: .word 0xFF
Je vais tester ton convertisseur maintenant, merci ! Et ne faut-il pas écrire str r2,[r0,#8]! ou quelque chose comme ça ? Je viens de finir un petit programme qui te permet faire bouger un pixel sur l'écran. Tu peux changer le couleur avec A :.arm
.include "gba.inc"
.text
.global main
main:
mov r0, #REG_DISPCNT @ Registre du display
mov r1, #BG2_ENABLE
add r1, r1, #MODE_3
str r1, [r0] @ Ecrire r1 dans [r0]
pixelLoop:
bl delay @ Comme la GBA est rapide !
ldr r0, =x
ldrb r0,[r0] @ Lire l'octet (coordonnée X)
ldr r1, =y
ldrb r1,[r1] @ Lire la coordonnée Y
ldr r2, =color
ldr r2,[r2] @ Lire la coordonnée Y
bl putPixel @ bl = branch link, charger l'adresse de la prochaine instruction dans lr (r14)
bl getKey @ r4 = touche
@ Quelle touche a-t-on poussée ?
ldr r0, =x
ldr r1, =y
tst r4, #KEY_UP
bleq keyUp
tst r4, #KEY_DOWN
bleq keyDown
tst r4, #KEY_RIGHT
bleq keyRight
tst r4, #KEY_LEFT
bleq keyLeft
tst r4, #KEY_A
bleq changeColor
b pixelLoop
mov r0, #VRAM
mov r1, #0x00 @ Le couleur
mov r5, #0x400
add r5, #0x21
mov r2, #0x9600 @ Combien d'iterations
loop1:
strh r1, [r0], #2 @ Store halfword (16 bits)
subs r2, r2, #1 @ Sub et mettre (Set) les drapeaux
bne loop1
add r1, r5 @ Les bits RGB sont dividés dans des groupes de 5 bits
add r1, r5, LSL #5 @ Donc on va ajouter un à chaque couleur
add r1, r5, LSL #10 @
mov r0, #VRAM
mov r2, #0x9600 @ Combien d'iterations
infin:
ldr r3,=KEYS
ldr r4,[r3]
ands r4,r4,#KEY_UP
bne infin
b loop1
keyUp:
ldrb r2, [r1] @ Charger octet (Y) à [r1] dans r2
subs r2, r2, #1 @ Y-1
bxcc lr @ Si Y-1 arme le drapeau C, quitter
strb r2, [r1] @ Sauver nouvelle coordonnée
bx lr @ Quitter la routine
keyDown:
ldrb r2, [r1] @ Y
add r2, r2, #1 @ Y+1
cmp r2, #160
bxcs lr
strb r2, [r1] @ Sauver nouvelle coordonnée
bx lr @ Quitter la routine
keyRight:
ldrb r2, [r0] @ X
add r2, r2, #1 @ X+1
cmp r2, #240
bxcs lr
strb r2, [r0] @ Sauver nouvelle coordonnée
bx lr @ Quitter la routine
keyLeft:
ldrb r2, [r0] @ X
subs r2, r2, #1 @ X-1
bxcc lr
strb r2, [r0] @ Sauver nouvelle coordonnée
bx lr @ Quitter la routine
@ r0 = X
@ r1 = Y
@ r2 = halfword à afficher
putPixel:
mov r3, r1, LSL #4 @ r3 = r1*16
sub r3, r3, r1 @ r3 = r1*15
mov r3, r3, LSL #5 @ r3 = r1*240*2 (largueur de l'écran, et chaque pixel occupe deux octets)
add r3, r0, LSL #1 @ r3 = r1*240+r0*2 (parce qu'un pixel occupe deux octets)
add r3, #VRAM
strh r2 , [r3] @ SToRe Halfword en r2 dans [r3]
bx lr @ = br r14 (ret)
@ On utilise bx pour sauter à une adresse dans un registre
getKey:
mov r3, #KEYS_HIGH @ MSB
orr r3, r3, #KEYS_LOW @ Ajouter LSB de l'adresse
mov r2, #0x300
orr r2, #0xFF @ r2 = $3FF
getKeyLoop:
ldr r4, [r3] @ Lire les touches poussées
teq r4, r2 @ Si nous n'avons pas appuyé sur une touche
beq getKeyLoop @ ... répéter
bx lr @ Quitter la routine
change
Et merci pour les nouveaux equates

J'ai fait quelques simples routines, une qui affiche un pixel, un genre de GetKey, et une routine pour faire un délai (la GBA est rapide ! Rapidissimo !)