Discussion :

[alex6502]

Bonsoir,

Débutant cette année l’informatique, il m’est demander de réaliser sous assembleur 6502 une addition de 5 chiffres à l’aide d’une boucle afin d’éviter d’utiliser 4 ADC.
Je me suis dépatouillé pour faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
0100//A2 03//LDX #$03
 
0102//86 50//STX $50
 
0104//A2 02//LDX #$02
 
0106//86 51//STX $51
 
0108//A2 06//LDX #$06
 
010A//86 52//STX $52
 
010C//A2 11//LDX #$11
 
010E//86 53//STX $53
 
0110//A2 0D//LDX #$0D
 
0112//86 54//STX $54
 
0114//A2 05//LDX #$05
 
0116//86 40//STX $40
 
0118//A6 40//LDX $40
 
011A//CA//DEX
 
011B//B5 50//LDA $50,X
 
011D//20 27 01//JSR $0127
 
0120//85 55//STA $55
 
0122//E0 00//CPX #$00
 
0124//D0 F4//BNE $001A
 
0126//00//BRK
 
0127//18//CLC
 
0128//A5 50//LDA $50
 
012A//65 51//ADC $51
 
012C//60//RTS

Qui bien entendu ne fonctionne pas comme je le souhaiterais. Je suppose qu’il y au moins un problème au niveau de la routine, puisque seule une addition est effectuée…
Pourriez-vous m’expliquer mes erreurs ?
En vous remerciant par avance.

[Kannagi]

Tu devrait utilisé la balise code.
Sinon vous utilisez un assembleur de l'avant guerre pour écrire les sauts en dur ? xD
Meme en assembleur nommer les variables , fonction , indenter son code ect est une regle qu'il faut suivre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
;met la valeur 0x03 dans l'adresse 0x50
LDX #$03
STX $50
 
;met la valeur 0x02 dans l'adresse 0x51
LDX #$02
STX $51
 
;met la valeur 0x06 dans l'adresse 0x52
LDX #$06
;010A:
STX $52
 
;met la valeur 0x11 dans l'adresse 0x53
LDX #$11
STX $53
 
;met la valeur 0x0D dans l'adresse 0x54
LDX #$0D
STX $54
 
;met la valeur 0x05 dans l'adresse 0x40
LDX #$05
STX $40
LDX $40
DEX 
LDA $50,X ;recupere dans le registre A , le contenu de l'adresse 0x50 + X
 
JSR $0127
 
;résultat a 0x55 donc
STA $55
 
CPX #$00
BNE $001A
 
BRK
 
;0127:
CLC
;addition 0x50 et 0x51
LDA $50
ADC $51
 
RTS

Moi je que je vois c'est que tu additionne toujous l'adresse $50 et $51 et comme leur valeur ne change pas , ton résulta ne risque pas de changer.

Vu que la ligne LDA $50,X , ne sert strictement a rien ,tu fait toute de suite apres LDA $50.

[alex6502]

Merci pour ta réponse, mais je crains qu'elle ne m’aie pas trop éclairée.

C’est en fait un cours d’initiation à l’informatique avec l’étude de l’architecture d’un processeur et le langage assembleur pour partir du plus bas possible et ensuite aller vers des langages plus élaborés.
En effet, j’additionne toujours les deux mêmes chiffres puisque je n’arrive pas à faire en sorte que le processeur aille chercher les autres données sans réécrire des ADC successifs.
L’objectif que j’essaye d’atteindre étant que l’assembleur fasse un nombre prédéfini d’additions, qui lui est relatif au nombre de données rentrées en mémoire, ici 5. Donc je crée un compteur qui tant qu’il n’arrive pas à 0, permet de faire tourner la routine d’addition et dès cette valeur atteinte arrête le programme.
Il y a déjà un problème au niveau de la routine, comme tu l’as dit, puisqu’elle ne fait qu’une opération, mais qui n’est peut-être pas le seul.

[Invité]

C’est en fait un cours d’initiation à l’informatique avec l’étude de l’architecture d’un processeur et le langage assembleur pour partir du plus bas possible et ensuite aller vers des langages plus élaborés.

Si ce sont tes profs qui t-on apprit cela sur l'asm, alors tu peux aller leur dire que l'asm est Le langage à part par excellence, on sait tous qu'il y a plusieurs asm, selon leur syntaxe, leur CPU host et sa complexité (CISC vs RISC vs other) et non pas comme le C/C++ où le langage ne diffère qu'entre compiler (mais pas beaucoup).

Et apparemment ton asm est d'un compliquée et ne fait que dégouter de la prog asm plus qu'apprendre comment ça marche à "l'interieur" alors voilà, dis à tes profs qu'ils se mettent à jour vite fait, cela fera un plus grand bien à cette communauté vraiment pas populaire.

Et de plus cela te montrera que le monde du bas niveau a aussi ses évolutions tout en restant fidèle à la philosophie du bas niveau, cela est assez tordu à comprendre, mais c'est comme ça ^^

[alex6502]

Bien que ce qu'il m'est demandé d'apprendre par cet exercice ne me servira pas à grand chose plus tard avec d'autres langages, hormis en ce qui concerne la phase réflexion, le problème majeur consiste dans le fait que cette manipulation fait partie d'un compte rendu noté, non rattrapable, et que ce n'est que la deuxième question sur 5 avec ordre croissant de complexité...

[Invité]

Bien que ce qu'il m'est demandé d'apprendre par cet exercice ne me servira pas à grand chose plus tard avec d'autres langages

C'est tout ce que tu as retenu de ce que j'ai dit ? pourquoi pas ^^ (enfin je me demande comment tu es arrivé à cette conclusion)

Mais a ce qu'il paraît, coder en asm t'apprend mieux à coder dans les autres langages selon mon expérience (on m'a fait la remarque à plusieurs reprise que je codais bien en C et j'ai fait le lien avec mon apprentissage de l'asm )

Sinon bonne continuation pour ton exo, malheureusement je ne peux t'aider, je ne connais pas ton asm ^^

[alex6502]

En réalité, je ne faisais référence qu'à la syntaxe propre à cet assembleur.
Merci de ton soutient.

[Invité]

Ahh ok ^^

np ^^

[Kannagi]

Je ne te ferait pas cet exercise a ta place ,si tu dois avoir une mauvaise , tu en aura une ^^'
Moi j'aime beaucoup le 6502 et je ne cache pas que c'est un de mes assembleur préferer

Sinon tu n'as qu'a remplacé simplement ton LDA $50 , par LDA $50,X , mais faudra voir c'est quoi la question exact parce qu'additioner le tout , je ne vois pas l'interet.

Si le but et de faire une boucle est additionner toutes les valeurs alors tu te complique la tache.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
LDA $50
 
LDX #4
CLC
-:
        ADC $50,X
        DEX
        CPX #0
        bne -
 
STA $55

Et apparemment ton asm est d'un compliquée et ne fait que dégouter de la prog asm plus qu'apprendre comment ça marche à "l'interieur" alors voilà, dis à tes profs qu'ils se mettent à jour vite fait, cela fera un plus grand bien à cette communauté vraiment pas populaire.

Si tu post sur un sujet que au final non seulement c'est pour dire "ah désolé je peux pas t'aider" et de troller , je vois pas l'interet de tes post franchement.
Le 6502 compliquée ? c'est probablement un des assembleurs les plus simples , un mois suffit largement pour le connaitre de bout en bout.

[alex6502]

Je m'attends pas à avoir la réponse toute cuite dans le bec mais quelques éclaircissements.
L'énoncé exact étant : "Soit une suite de nombre entier positif (j'ai choisi 5). En faire la somme à l'aide d'une boucle."

[Invité]

Bah, au moins j'ai réussi à lui dire ce que j'en pense et il n'est pas aussi en désaccord que toi

Et cela vaut aussi pour toi, c'est tout ce que tu as retenu de ce que j'ai dit, enfin quoique c'était juste un malentendu la première fois ^^

Après si tu es un fervent défenseur de cet asm comme moi avec nasm sur intel, ok pourquoi pas, désoler de t'avoir froissé ^^

[Kannagi]

Je m'attends pas à avoir la réponse toute cuite dans le bec mais quelques éclaircissements.
L'énoncé exact étant : "Soit une suite de nombre entier positif (j'ai choisi 5). En faire la somme à l'aide d'une boucle."

Disons que comme tu m'as dit que ma réponce ne t'as pas éclairé et que ton souci n'est que d'ordre algorhytmique , je me suis permis de faire directement la réponce.
Peu importe le langage il faut toujours avoir l'algo en tete , encore plus si on débute en assembleur , ça évite de faire un code comme le tiens que je ne trouve vraiment pas intuitive pour faire seulement 5 additions.

Sinon une question tu fait crt assembleur sur quel architecture ? Vu que pour ma part je n'y est touché que sur la Nes et la Super Nintendo.
En france il y a une bonne communauté du 6502 surtout a cause des vielles machine comme l'Atari , Apple et le Commodore 64.

Après si tu es un fervent défenseur de cet asm comme moi avec nasm sur intel, ok pourquoi pas, désoler de t'avoir froissé ^^

C'est relatif , si tu sors sans argument je défendrait probablement le 6502 avec 'archanement' , mais si tu as testé plusieurs assembleur et que tu dis par ton expérience perso que certain facilite leur compréension je comprendrait.
J'ai touché a pas mal d'assembleur , que cela soit du x86 , z80 , 68000 , 6502 , du MIPS et du ARM , je n'en déteste aucun mais je trouve certain plus prompt a l'apprentissage que d'autre.

[Invité]

Le seul argument que j'ai à propos de ce langage est à propos de sa syntaxe:

À propos de ces symboles ésotérique: #$ avant les nombres
J'ai du mal à construire la définition de ses instructions, même en voulant trouver le mot composant les acronymes des mnémoniques, enfin c'est assez hard.

[Kannagi]

Le seul argument que j'ai à propos de ce langage est à propos de sa syntaxe:

À propos de ces symboles ésotérique: #$ avant les nombres
J'ai du mal à construire la définition de ses instructions, même en voulant trouver le mot composant les acronymes des mnémoniques, enfin c'est assez hard.

C'est une question d'habitute , mais ce n'est pas le seul qui a cette syntaxe
Le 68000 a le meme , et le z80 presque lui aussi.
le # signifie que c'est une valeur immédiate , le $ c'est pour dire que c'est de l'hexa.
vu que ecrire une valeur en dure comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

LDA 50

LDA pour LoaD Accumulateur
Cela veut dire que dans le registre A tu me le contenu de ce qui se trouve dans l'adresse 50.
Si on veut mettre la valeur 50 dans A alors on l'écris comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

LDA #50

Bref rien de bien sorcier et on s'y habitue assez vite

[Invité]

Mouais, assez tordue quand même enfin peut-être parce que la religion nasm m'interdit d'aller voir ailleurs peut-être, psychologiquement parlant

Mais faut avouer que c'est assez original et bon ... intéressant en chemin, je le dis vraiment contre mon gré là

[alex6502]

Si je traduis en code opératoire ce que tu as écrit cela donne bien cela ?
LDA $50 --> A5 50 /*en page zéro, chargement de l’accumulateur avec la donnée en adresse 50

LDX #4 --> A2 04 /*immédiat, charger le registre X avec la valeur 04
CLC -->18
-:
ADC $50,X -->7D 50 ?? /*en absolue,X ce code nécessite 3 pairs de bits, est-ce 00 dans ce cas, si oui ou non surtout pourquoi ?
DEX --> CA
CPX #0 --> E0 00 /*immédiat
bne - --> D0 00

STA $55 --> 85 55 /* en page zéro, adressage du résultat en 0055

J’ai un peu de mal avec les différents modes d’adressages, qui d’ailleurs sont utilisés dans la troisième question qui porte sur la réalisation de la même somme avec un adressage indirect indexé.

[Kannagi]

N'oublie pas pas de mettre les balices code ,ça fait deux fois que je te le dis .

ADC $50,X -->7D 50 ?? /*en absolue,X ce code nécessite 3 pairs de bits, est-ce 00 dans ce cas, si oui ou non surtout pourquoi ?

3 pairs de bits ? tu veux dire 3 pairs octet non ?
L'opcode est de 7D 00 50 , je pense mais si tu veux la confirmation regarde le code générer avec un editeur hexadécimal

D'ailleurs pourquoi tu as besoin d'écrire les opcode ? tu assemble a la main ou quoi ?

J’ai un peu de mal avec les différents modes d’adressages, qui d’ailleurs sont utilisés dans la troisième question qui porte sur la réalisation de la même somme avec un adressage indirect indexé.

Le meilleur moyen pour comprendre c'est de testé son code.
Pour adressage indirect indexé , si je me trompe pas c'est comme les pointeurs , par exemple ADC ($20,X) ,signifie qu'on additionne le registre A avec ce qui se trouve dans le contenu de l'adresse $20 + X.

Sinon tu n'as pas répondu a ma question , tu utilise le 6502 sur quel machine ?

[alex6502]

N'oublie pas pas de mettre les balises code ,ça fait deux fois que je te le dis .

Je n'ai pas encore vu ce qu'était une balise, juste quelques vagues connaissances en Java d’où mes "/*" pour un commentaire.

D'ailleurs pourquoi tu as besoin d'écrire les opcode ? tu assemble a la main ou quoi ?
...

Sinon tu n'as pas répondu a ma question , tu utilise le 6502 sur quel machine ?

J'utilise le simulateur Soft6502 disponible en téléchargement et qui demande de rentrer les opcode pour les tester car effectivement :

Le meilleur moyen pour comprendre c'est de testé son code.

Sinon, aussi le site e-tradition.

Pour ce qui est de l'adressage indirect indexé, d'après mon listing de commande, seule JMP (Jump) possède un tel adressage. Du coup, pour cet énoncé ma solution (non encore réalisé) serais de charger mon adresse dans la mémoire X ou Y puis de faire un adressage direct indexé, ce qui ressemble plus à du bidouillage qu'à la réponse à la question.

[Kannagi]

je te parle de la balise du forum
Donc te faire un (sans les espace):[ CODE][ /CODE]

Pour Soft6502 tu es obligé de l'utiliser ?, parce que rentrée directement les opcodes un a un...
Sinon il y a http://www.6502asm.com/ pour testé rapidement.
Et au long terme si tu veux continuer le 6502 , je te conseille d'utiliser une machine de ton choix (et donc un émulateur Apple II, Nes , Super nintendo , Commodore , atari ect).

Pour le indirect indexé non il y a LDA , ADC ect
Mais effectivement pour le Absolute Indexed Indirect , oui il n'y a que le Jump.

Apres je ne connait ni la question ni encore ton code donc pour le moment je ne peux que 'attendre' ton post je peux effectivement le vérifier mais j'espere que tu y arrive seul son mon aide.
Disons que lire ton code n'est vraiment pas intuitive , si tu le faisais sur un assembleur (donc sans opcode et sans les adresses ect) je pourrait test ton code et donc t'aider plus aisément.

Voici un bout de code d'un jeu sur Super Nintendo si cela peut te donné l'idée d'un gros code et donc que ta façon de faire c'est ce mettre quelque baton dans les roue pour débuté (meme si c'est interessant de faires les opcodes soit meme au debut mais si c'est pour faire des exercises un peu plus poussé il faut mieux laisser un assembleur un peu gerer le reste).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
.include "header.asm"
.include "snes.asm"
 
.include "mtext.asm"
.include "init.asm"
.include "mdraw.asm"
.include "mjoypad.asm"
.include "mzorder.asm"
.include "mdma.asm"
.include "random.asm"
.include "variable.asm"
 
.define LIMIT_CAMERAX    54
.define LIMIT_CAMERAW    -72
.define LIMIT_CAMERAY    48
.define LIMIT_CAMERAH    -104
 
.define SPC_FILE "music/sd2-02.spc"
;.define SPC_FILE "music/01plain.spc"
 
.bank 0 slot 0
.org 0
 
Main:
	clc
    xce
 
	lda 	#0
	jsr 	LoadSPC
 
	rep #$10	;16 bit xy
 
	ldx #0
	stx s_map + $0E
	init_rand
 
 
	Begin:
	jsr Map_choix
 
    SNES_INIT
 
    ;INITIAL SETTINGS
 
	;object
	SNES_OBJSEL $63 ; 16x16 , $6000 address
 
	;background
	SNES_BGMODE $39 ; BG 1 & 2 16x16, BG 3 8x8,mode 1 , BG 3 pri
 
	SNES_BG1SC $50 ; address data BG1 $5000
	SNES_BG2SC $54 ; address data BG2 $5400
	SNES_BG3SC $58 ; address data BG3 $5800
 
	SNES_BGNBA $20 $04; address BG1,2,3,4 (2,1 / 4,3)
 
	;general init
	SNES_SETINI $00
	SNES_MEMSEL $00
    SNES_TM $17 ; obj & bg 1,2,3 enable
    SNES_COLDATA $E0
 
    SNES_VMAINC $80
    SNES_INIDISP $8F ; FORCED BLANK , brigtness 15
    ;FORCED BLANK
 
    ;Load Object
    SNES_DMAX $01
	SNES_DMAX_BADD $18
 
    SNES_VMADD $7800
 
	SNES_DMA0_ADD invocation $0400
	SNES_DMA1_ADD invocation $0800	
	SNES_DMA2_ADD Menu $0400	
 
    SNES_MDMAEN $07
 
    ;Load bg 3
	SNES_VMADD $4000
	SNES_DMA0_ADD Texte $0400
	SNES_DMA1_ADD wmenu1 $40
    SNES_MDMAEN $03
 
    SNES_VMADD $4400
	SNES_DMA0_ADD Texte2 $0C00	
    SNES_MDMAEN $01
 
    ldx #s_map + $20
    jsr (0,X)
 
 
    ;Object Palette
    SNES_CGADD $E0
 
    SNES_DMA0_ADD pallette_invocation1 $0020
    SNES_DMA1_ADD pallette_invocation2 $0020
 
    SNES_MDMAEN $03
 
    ;BG Palette
    SNES_CGADD $00
    SNES_DMA0_ADD pallette_text $0008
    SNES_DMA1_ADD pallette_wmenu1 $0008
    SNES_DMA2_ADD pallette_font8x16 $0008
    SNES_MDMAEN $07
 
    ;initialisation
    init_bg $0000
    init_britgness
    init_oam
    init_zoam
    init_scrolling
    init_control
    init_dma
    init_text
    init_msb
    init_perso
    init_menu
    stz MEM_PAL + 0
	stz MEM_PAL + 1
	stz MEM_PAL + 2
	stz MEM_PAL + 3
	stz MEM_PAL + 4
 
	ldx #Eagle1
	stx MEM_DMA + 2
 
	ldx #s_map + $22
	jsr (0,X)
 
 
 
	;Vblank call
	ldx #0
	stx MEM_VBLANK
 
	SNES_NMITIMEN $81 ; Enable NMI , enable joypad
 
 
	SNES_INIDISP $00 ;  brigtness 0
 
 
	lda #-32
	ldx #0
	-:
		sta t_oam,X
		inx
	cpx #128
	bne -
 
	stz $1400
	stz $1401
	stz $1402
	stz $1403
 
 
	;Begin game
	Game:	
 
		lda MEM_STDCTRL + $06	; read joypad 1 Start
		cmp #1
		bne +	
			jml Mode7
		+:
 
		lda MEM_STDCTRL + $07	; read joypad 1 Start
		cmp #1
		bne +	
			jml Begin
		+:
 
		jsr Random
 
		stz MEM_OAM + $08
		stz MEM_OAM + $09
		stz MEM_OAM + $0A
 
		stz $1325
		stz $1328
		stz $1330
		stz $1338
 
		jsr precalcul_scrolling_ch
		stz s_map + $0D
 
		SNES_INIDISP $8F
 
 
		; Joypad
		jsr Joypad
 
 
		; Draw hero 1
		jsr Draw_hero
		inc MEM_OAM + $08 ; pour le hero n'2
 
		;Map pnj
		ldx #s_map + $24
		jsr (0,X)
 
		;Menu
		jsr Draw_menu
 
		SNES_INIDISP $0F
 
		jsr Luminosite_clair
 
		lda MEM_BRIGTNESS
		and #$30
		cmp #$30
		beq +
			lda s_map + $0C
			cmp #$0
			beq +
				jsr Map_change
				lda MEM_TEMPFUNC
				cmp #$0
				beq +
					lda #$3F
					sta MEM_BRIGTNESS
		+:
 
		jsr Luminosite_sombre
		lda MEM_BRIGTNESS
		cmp #$40
		bne +
			jmp Begin
		+:
 
		;collision
		ldx #$00 ; hero 1
		stx MEM_TEMPFUNC
 
		jsr Collision_perso
		jsr Collision_perso_text
		jsr Collision_mur
		jsr Deplacement_hero
 
 
 
		;Scrolling
		jsr Scrolling
 
		;Tri
		jsr Tri_zorder
 
		lda MEM_BRIGTNESS
		sta $1330
 
		lda MEM_BRIGTNESS + 1
		sta $1338
 
		wai
 
 
		lda #-32
		ldx #0
		-:
			sta t_oam,X
			inx
		cpx #128
		bne -
 
 
 
 
    jmp Game
 
Random:
	mRand8
	rts
 
Map_transition:
 
 
 
	rts
 
Text:
		;text
 
		textec 2,2,$2038 ; X
		textec 2,3,$2039 ; Y
 
		;texte1 0,0 ; test 123
 
		lda s_perso
		printf 4,2
 
		lda s_perso + 1
		printf 4,3
 
		lda MEM_HSCROLLING
		printf 2,4
 
		lda MEM_VSCROLLING
		printf 6,4
 
		;test string
		ldx	#text_s1
		printfs 2,5,text_s1
 
		lda $1325
		printf 2,6
 
		lda $1328
		printf 8,6
 
		lda $1330
		printf 14,6
 
		lda $1338
		printf 20,6
 
		;mRand8
		;lda rand8
		;printf 0,9
 
		lda #8
		sta WRMPYA
		lda #7
		sta WRMPYB
 
 
		; Affichage d'un nombre sur 16 bits
		;ldy #18000
		ldy RDMPYL
		print_16_bit_integer 10,2	; ça marche même avec -32768 mais je ne sais pas pourquoi alors que la limite est normalement dépassée ! bref.
 
	rts
 
text_s1:
	.db "hello world",0
 
	.include "hero.asm"
 
	.include "choix_map.asm"
 
 
	.include "map_pnj.asm"
 
	.include "oam.asm"
 
	.include "precalcul.asm"
 
	.include "tri.asm"
 
	.include "collision_perso.asm"
	.include "collision_pnj.asm"
 
	.include "scrolling.asm"
 
	.include "joypad.asm"
 
	.include "VBlank.asm"
 
	.include "menu.asm"
 
	.include "text.asm"
 
	.include "dma.asm"
 
	.include "pnj.asm"
 
	.include "map.asm"
 
	.include "loadspc.asm"
 
Sincos:
	.include "rotation/sincos_menu.asm"
 
Randomp:
	.include "DATA/random.asm"
 
.org $7FB0
	header
.bank 1 slot 0
.org 0
 
 .incbin SPC_FILE skip $00025 read $0008
 ; DSP register values
 
map1:
	.include "DATA/maps.asm"
 
mapc2:
	.include "DATA/collision2.asm"
 
 ;.include "DATA/collision.asm"	
 .org $4000
 .incbin SPC_FILE skip $10100 read $0080
 
 
 
map2:
	.include "DATA/maps2.asm"
 
mapc:
	.include "DATA/collision.asm"
 
 
 
.bank 2 slot 0
.org 0
 
	;.include "DATA/texte.asm"
	.incbin SPC_FILE skip $0100 read $8000
 
 
.bank 3 slot 0
.org 0
 
	.incbin SPC_FILE skip $8100 read $8000
 
 
 
.bank 4 slot 0
.org 0
 
Jean:
	.include "DATA/Jean.asm"
 
old_man:
	.include "DATA/old_man.asm"
 
Man:
	.include "DATA/man.asm"
 
Soldat:
	.include "DATA/soldat.asm"
 
Papi:
	.include "DATA/Papi.asm"
 
.bank 5 slot 0
.org 0
 
tile2:
	.include "DATA/tile2.asm"
 
tile4:
	.include "DATA/tile4.asm"
 
tile5:
	.include "DATA/tile5.asm"
 
 
Texte:
	.include "DATA/text.asm"
 
Texte2:
	.include "DATA/font8x16.asm"
 
 
 
Menu:
	.include "DATA/menu.asm"
 
 
invocation:
	.include "DATA/invocation.asm"
 
wmenu1:
	.include "DATA/wmenu1.asm"
 
OAM_vide:
	.REPT $200
	.db $E0
	.ENDR
 
Vide:
	.REPT $200
	.db $00
	.ENDR
 
 
Fenetre_data:
.dw $2440,$2441,$2441,$2441,$2441,$2441,$2441,$2441
.dw $2441,$2441,$2441,$2441,$2441,$2441,$2441,$2441
.dw $2441,$2441,$2441,$2441,$2441,$2441,$2441,$2441
.dw $2441,$2441,$2441,$2441,$2441,$6440
 
Fenetre_data2:
.dw $A440,$2441,$2441,$2441,$2441,$2441,$2441,$2441
.dw $2441,$2441,$2441,$2441,$2441,$2441,$2441,$2441
.dw $2441,$2441,$2441,$2441,$2441,$2441,$2441,$2441
.dw $2441,$2441,$2441,$2441,$2441,$E440
 
Fenetre_data3:
.dw $2443,$2443,$2443,$2443,$2443,$2443,$2443,$2443
.dw $2443,$2443,$2443,$2443,$2443,$2443,$2443,$2443
.dw $2443,$2443,$2443,$2443,$2443,$2443,$2443,$2443
.dw $2443,$2443,$2443,$2443,$2443,$2443,$2443,$2443
 
Eagle1:
	.include "DATA/eagle1.asm"
 
.bank 6 slot 0
.org 0
;pallete
	.include "DATA/effect.asm"
 
	.include "DATA/texte.asm"
 
	.include "background.asm"
 
 
tile7:
	.include "DATA/tile7.asm"
 
tile8:
	.include "DATA/tile8.asm"
 
tile9:
	.include "DATA/tile9.asm"
 
 
 
.bank 7 slot 0
.org 0
 
map3:
	.include "DATA/map3.asm"
 
map4:
	.include "DATA/map4.asm"
 
tile13:
	.include "DATA/tile13.asm"
 
tile14:
	.include "DATA/tile14.asm"
 
tile15:
	.include "DATA/tile15.asm"
 
	.include "DATA/eau.asm"
 
.bank 8 slot 0
.org 0
	.include "mode7.asm"
 
.bank 9 slot 0
.org 0
 
Map:
	.incbin "DATA/map7"
Tiles:
	.include "DATA/mode7.asm"
 
.bank 10 slot 0
.org 0
 
SinCos:
	.include "rotation/sincos.asm"
 
SinCosmenu:
	.include "rotation/sincos_menu.asm"
 
.bank 11 slot 0
.org 0
 
Randi:
	.include "DATA/randi.asm"

Il y a pas mal de Macro , mais c'est de mon point de vue indispensable si on veut codé rapidement en assembleur.

[alex6502]

Je ne suis pas prêt d’arriver à ce genre de résultat et d’ailleurs je n’en aurai pas le temps par ma formation, ce devoir étant la dernière manipulation en assembleur.

Au final, je pense ne pas avoir compris correctement les différentes mécaniques du 6502, que ce soit les adressages, les notions de pile…
Puisque la solution à l’objectif, à savoir réaliser une succession d’addition par le biais d’un compteur décrémenté, qui quand il atteindra 0 mettra fin au programme en donnant le résultat escompté, m’échappe depuis de nombreuses heures et des dizaines d’essais sans que je ne comprenne véritablement les raisons, ou en tout cas la mécanique sous-jacente. Pourtant, il n’y a pas tant d’instructions qui pourraient être utilisées, mais leurs agencements et leurs adressages me reste opaque.

En tout cas merci d’avoir essayé de m’aider, mais je pense que pour bien faire les choses il me faudrait quasiment un cours mais surtout de nombreuses manipulations.

Je vais tout de même continuer à tenter des choses jusqu'à l'heure du rendu mais j'ai l'impression d'être dans une chambre chinoise inversé, puisque je connais la définition des différentes instructions, mais sans pouvoir les structurées en un programme.