Re: [ TERMINE ] - Papi Commando Megadrive Edition !

par Invité Lun 16 Fév 2015 - 12:54

Euhhhh ...
A vrai dire j'essais de comprendre en bidouillant de ci de là mais sans grand succès.
Easy68K ne me permet pas de suivre le déroulement pas à pas car le code fait appel à des spécifications Hard de la MD.
Bref, c'est encore (trop) obscur pour moi.

par nemokantio Lun 16 Fév 2015 - 13:36

Le hic c'est que moi je ne connais pas la megadrive !
(et j'ai quelques notions de 68000)
Mr. Green

Mais actuellement, le player fait quoi ?
Ce te lit un fichier wav, mais reste bloqué après ?
Essaye de rajouter :
jsr StopPlay
rts
juste après le bne.s codestart, juste pour voir...

par tfdi Lun 16 Fév 2015 - 15:34

En ayant survolé vite fait ton source (désolé, chuis au boulot là ... ^^), essaye en supprimant ces 2 lignes (tu les effaces carrément) :

Code:: btst #$A0004A,(A1) ; Fin du morceau et rebouclage ?! bne.s codestart

D'après ce que j'ai vu vite fait, l'adresse $A0004A contient un flag de looping.

Essaye en supprimant ces 2 lignes, si ca ne fonctionne pas, dis me le, je te ferai faire une petite modif au code ... Wink

par Invité Lun 16 Fév 2015 - 22:21

Merci pour ton aide ! Wink

En fait, le code se déroule bien, il n'y a qu'un bruit de distortion de quelques secondes juste à la fin du morceau, un truc que je n'arrive pas à régler.

Par contre, j'ai une question très importante et besoin de renseignement ... Je n'arrive pas à comprendre comment choisir un fichier son dans mon code ASM et de par le fait, comment se déroule réellement le code !

Code:: CodeStart: MOVE.W #$2700, SR ; Disable ints move.w #$100,($A11100) ; Send the Z80 a bus request. move.w #$100,($A11200) MOVE.W #447, D0 LEA Z80prog, A0 MOVE.L #$A00000, A1 Z80loadLoop: MOVE.B (A0)+, (A1)+ DBRA D0, Z80LoadLoop ;On charge le driver Z80 dans sa mémoire move.w #$100,($A11100) ; Send the Z80 a bus request. move.w #$100,($A11200) ; Z80 Reset move.w #$000,($A11100) LEA WAVfile, A0 ; Give the address of WAV JSR GiveAddress MOVE.B #4, D0 ; 12KHz JSR GiveTimeConstant MOVE.B #1, D0 ; Start playback JSR GiveCommand GiveAddress: ; Give Z80 program the address of WAV MOVE.W #$100, ($A11100) ; request Z80 bus MOVE.L #$A00040, A1 MOVE.L A0, D0 MOVE.B D0, (A1)+ LSR.L #8, D0 MOVE.B D0, (A1)+ LSR.L #8, D0 MOVE.B #$00, ($A11100) ; unrequest Z80 bus RTS GiveCommand: ; Give the Z80 program a command MOVE.W #$100, ($A11100) ; request Z80 bus MOVE.B D0, ($A00043) MOVE.B #$00, ($A11100) ; unrequest Z80 bus RTS GiveTimeConstant: ; Give the Z80 program a Time constant MOVE.W #$100, ($A11100) ; request Z80 bus MOVE.B D0, ($A00044) MOVE.B #$00, ($A11100) ; unrequest Z80 bus RTS Z80prog: ; Z80 WAVPLAY INCBIN "Z80WAVD.BIN" WAVFile1: INCBIN "Papitheme.Raw" WAVfile: INCBIN "Papi.Raw" ;------------------------------------ ; Sous programme de Reset HARD du Z80 ;------------------------------------ Init_Z80: move.w #$100,($A11100) ; Send the Z80 a bus request. move.w #$100,($A11200) ; Reset the Z80. Init_Z80_WaitZ80Loop: btst #0,($A11100) ; Has the Z80 reset? bne.s Init_Z80_WaitZ80Loop ; If not, keep checking. lea (Init_Z80_InitCode),a0 ; Load the start address of the code to a0. lea ($A00000),a1 ; Load the address of start of Z80 RAM to a1. move.w #Init_Z80_InitCode_End-Init_Z80_InitCode-1,d1 ; Load the length of the Z80 code to d1. Init_Z80_LoadProgramLoop: move.b (a0)+,(a1)+ ; Write a byte of Z80 data. dbf d1,Init_Z80_LoadProgramLoop ; If we have bytes left to write, write them. move.w #0,($A11200) ; Disable the Z80 reset. move.w #0,($A11100) ; Give the Z80 the bus back. move.w #$100,($A11200) ; Reset the Z80 again. rts ; Return to sub. ;---------------------------------------------- ; Below is the code that the Z80 will execute. ;---------------------------------------------- Init_Z80_InitCode: dc.w $AF01, $D91F, $1127, $0021, $2600, $F977 dc.w $EDB0, $DDE1, $FDE1, $ED47, $ED4F, $D1E1 dc.w $F108, $D9C1, $D1E1, $F1F9, $F3ED, $5636 dc.w $E9E9 Init_Z80_InitCode_End:

Rien de bien compliqué ... Ma question concerne la ligne :

Lea Nomdufichier,a0

Lorsque je veux qu'il me joue la 2eme piste, WavFile, en fait, il joue la 1ere WavFile1 ...
Il y a un truc pas logique que je ne pige pas dans le déroulement du programme ... WaveFile et WaveFile1 sont considérés comme quoi ?!
Quand le LEA va chercher cette "variable", que se passe t'il ensuite ?! Le programme se termine comment ? Il va prendre en compte WaveFile et WavFile1 ?!
Comment se termine la fin d'un code et le séparer de ce type de données ?!
Bref, j'ai vraiment besoin d'éclaircissements ...
Merci !! Wink

par tfdi Mar 17 Fév 2015 - 9:27

Sans connaître le Z80 ni les spécificités de la Megadrive, c'est pas évident, mais je dirai que pour jouer un autre "morceau" il faut que tu utilises ca:

Pour le 1er

Code:: LEA WAVfile, A0 ; Give the address of WAV JSR GiveAddress MOVE.B #4, D0 ; 12KHz JSR GiveTimeConstant MOVE.B #1, D0 ; Start playback JSR GiveCommand

Et pour le second, tu rappelles ca:

Code:: LEA WAVfile1, A0 ; Give the address of WAV JSR GiveAddress MOVE.B #4, D0 ; 12KHz JSR GiveTimeConstant MOVE.B #1, D0 ; Start playback JSR GiveCommand

Il faut que tu rappelles au moins ces 6 lignes de code.

Sous réserves qu'il n'y a pas autre chose à modifier/réinitialiser au niveau du Z80.

WaveFile et Wavefile1 sont considérés comme des "DATA".

Un INCBIN, c'est un include binarie, il inclut les données du fichier en "brut", en recopiant octet par octet le contenu du fichier à l'adresse du label.

LEA wavefile,a0

Ca donne l'adresse du label wavefile à A0, uniquement, ca n'exécute pas un programme.

Je suppose que le Z80 exécute le code qui permet de lire les données du fichier son en parallèle du 68000, un peu style une interruption.

Je suppose que la "fonction" giveaddress permet d'initialiser le fichier pour le Z80 (probablement copie dans un buffer, calcul de la longueur, etc ...), le "givecommand" doit envoyer un commande d'exécution pour la lecture ou un truc du genre, et la fonction "givetimeconstant" doit donner la fréquence de lecture. Attention, ce ne sont que des déductions, quelqu'un connaissant la Megadrive pourrait peut être me corriger si je dis des betises ... ^^

par Invité Mar 17 Fév 2015 - 9:45

Tes déductions rejoignent bien les mienne, et ta solution de séparer les 2 Lea, j'avais testé hier sans succès.
Le code me joue toujours la première variable déclarée sans tenir compte de la 2 ème. D'où ma question sur le déroulement du code.
Je pense que je me suis attaqué a un tros gros morceau pour le moment ... Dommage il me semblait que j'avais pigé pas mal de concepts mais pas tant en fait ! ^^

par nemokantio Mar 17 Fév 2015 - 9:55

Le souci vient peut être que le 68000 exécute le code pour le deuxième wav, alors que le premier est en train de se jouer par le z80...
Du coup, le deuxième passe à la trappe.

Peut être qu'il faut une sorte de boucle de temporisation, qui teste si un wav est en train d'être joué ou pas, avant d'en jouer un autre.

Ensuite, pour le déroulement du code comme tu dis, pour moi il manque un rts juste avant le GiveAddress.
Vu que ce sont des sub routines, il ne faut pas qu'elles s'exécutent après la fin de la routine principale.

par tfdi Mar 17 Fév 2015 - 11:53

Heu ... évidemment, il ne faut pas que tu exécutes les 2 LEA en suivant, ca ne fonctionnera pas.

Il faut temporiser via une boucle d'attente ou un truc du genre (touche appuyee, etc ...).

En clair, tu fais ton play wavfile1, une attente, et ensuite tu fais ton play wavfile2. Si t'as pas d'attente, les 2 LEA d'affilé ca fera au mieux le play d'une routine, et d'une seule si t'as pas de plantage.

Sinon, fais un copier/coller de ton source complet, parce là il manque des morceaux, et j'ai l'impression qu'on ne se comprend pas.

par Invité Mar 17 Fév 2015 - 12:15

Le code complet est au dessus, sans mes modifications, c'est celui d'origine.
J'attendais juste vos idées, modifications et voire ensuite avec les mienne pour mieux comprendre.
Sinon, Quid d'une boucle d'attente ? Tempo ? Surtout en assembleur ?!
Je comprends ce qu'il faut faire, je code depuis plus de 30 ans, mais je crois avoir bruler trop d'étapes ! MDR

[ TERMINE ] - Papi Commando Megadrive Edition ! - Page 8 418468

J'arrive à comprendre comment fonctionne un branchement conditionnel ( BEQ ou DBRA comme dans l'exemple ci dessus ), pour une tempo, euh ... On incrémente un registre et quand il atteint une certaine valeur, on sort ?!

Tempo (? ):
Move #0100, d0

Boucle :
Move.w d0,(A0)+
dbra d0,boucle

En fait, j'en sais trop rien ... Cet assembleur, c'est simple et compliqué à la fois.
Je n'arrive pas à synthétiser comment on pourrait créer une boucle For - Next, une condition If - Then, bref, ce qui fait la base de la programmation.

par tfdi Mar 17 Fév 2015 - 13:20

Je confirme, tu veux aller trop vite, et t'as brule toutes les étapes en fait ... ^^. L'assembleur c'est pas compliqué, mais il y a beaucoup de subtilités. Bien comprendre ces subtilités, c'est ca qui prend du temps.

Pour une boucle d'attente, tu peux faire un truc comme ca:

Code:: move.l $FFFFFF,d0 wait sub.l #1,d0 bne.s wait

Juste pour rire, ton #100, t'aurai même pas le temps de le voir passer ... c'est de l'assembleur ... MDR

Personnellement, pour avoir une boucle d'attente (une vraie), j'inclus la synchro VBL dans la boucle, comme ca, quand t'es à 50hz, tu sais qu'un $31 te fait attendre 1 seconde, et qu'un $319 te fait attendre 10 secondes. Malheureusement, je ne saurai te dire comment faire ca sur la Megadrive.

Là, sous easy68k, j'ai environ 7 secondes d'attente, à toi de monter ou descendre la valeur de d0 avec le move.l en fonction de ce que tu veux.

Quand t'as passé ta boucle, tu relances une lecture pour le 2ieme fichier style:

Code:: LEA WAVfile1, A0 ; Give the address of WAV JSR GiveAddress MOVE.B #4, D0 ; 12KHz JSR GiveTimeConstant MOVE.B #1, D0 ; Start playback JSR GiveCommand

Pas sûr que ca fonctionne, à cause du Z80, il faut peut être réinitialiser un ou plusieurs registres/adresses entre les 2 passages des 2 fichiers, il faut tester pour voir.

Ca va être difficile pour toi de créer/modifier des routines assembleur, sans connaitre un minimum le dit assembleur.

Si tu veux dév sur le Megadrive, Il faut que tu prennes le temps d'apprendre un minimum d'asm68k, de Z80, et de spécificitées de la MegaDrive, ce qui te prendra plus de quelques jours, c'est certain Wink

par nemokantio Mar 17 Fév 2015 - 13:24

Te décourage pas !

Je vais essayer de te donner des exemples, je m'excuse à l'avance si mon pseudo 68000 est trop approximatif !
Confused

La boucle :

For i=0 to N
trucs à faire
Next

En pseudo 68000 :

Code:: move.w N,D0 etiquette_boucle : trucs à faire dbra D0, etiquette_boucle ; dbra doit décrementer d0 et boucler si pas = 0

A noter que le compteur est dans le registre D0, alors que j'ai utilisé une variable I en écrivant le for, mais rien n'empêche d'utiliser une variable compteur aussi en asm (sauf que c'est plus lent).
Et là c'est propre au 68000 qui a l'instruction dbra, on peut l'écrire autrement même en 68000 :

Code:: move.w 0,D0 etiquette_boucle: trucs à faire add.w 1,D0 ; D0<-D0+1 cmp.w N,D0 ; compare à N blt etiquette_boucle ; si D0<N on revient à etiquette_boucle

Là c'est mal écrit pour un puriste par contre, mais c'est pour l'idée !

le test/condition :
if a=15 then
trucs du si
else
trucs du sinon
fin si

en pseudo 68000 :

Code:: lea a,D1 ; charge var a en D1 (je crois) cmp.w 15,D1 bne etiquette_sinon ; branch non equal trucs du si bra etiquette_finsi ; faut sauter le sinon etiquette_sinon: trucs du sinon etiquette_finsi:

Mais pour la tempo entre deux son, je pense que le top serait d'arriver à tester si le z80 est occupé à jouer un wav ou pas...

par **drfloyd** Mar 17 Fév 2015 - 13:25

Vetea a toujours été un homme pressé

par Invité Mar 17 Fév 2015 - 14:14

Nemokantio : MERCI !!! Voila juste ce que je cherchais ! Wink " alt=" Wink " title=" Wink ">

Sinon, oui j"ai toujours été impatient dans l'âme, c'est dans ma nature, c'est une qualité qui a beaucoup de défauts ... Wink " alt=" Wink " title=" Wink ">

Je rafistole mon T200 car Windows 8.1 me pose pas mal de soucis encore ...

A bientôt je vous tiendrai informé de mes travaux ! Wink " alt=" Wink " title=" Wink ">

par **F.L** Mar 17 Fév 2015 - 18:22

depuis que ça parle en assembleur, je suis largué MDR

je te souhaite d'arriver à tes fins avec cette musique et de pouvoir l'integrer à Bex. si tu y arrive, n'oublie pas de donner tes codes sur le forum de Bex, car ça va interesser du monde !!!
@+

par Invité Mar 17 Fév 2015 - 18:26

Je partage souvent sinon toujours mes sources F.L ! Wink

Vous serez les premiers informés quand j'arriverai à mes fins.

par tfdi Mar 17 Fév 2015 - 19:01

Vetea:File moi un petit fichier zip avec les fichiers raw et compagnie, une petite explication pour que je puisse compiler les sources, et tester en environnement sous emulateur Megadrive, je vais zieuter ca si tu veux Wink

par Invité Mar 17 Fév 2015 - 21:06

Merci pour ton aide tfdi !

Voici le fichier .zip avec toutes les sources :
https://dl.dropboxusercontent.com/u/108143465/Projet%20Player%20ASM%2068K%20MD.zip

Bon courage ! Wink

par **drfloyd** Mar 17 Fév 2015 - 21:44

tfdi HELP DESK officiel des programmeurs de Gamopat Mr. Green

par tfdi Mar 17 Fév 2015 - 22:08

Vetea:Ah mer** ... asm68k ne fonctionne pas sur un Windows 64 bits ... -.- ... bon, je n'ai plus qu'à installer une machine virtuelle avec un Windows en 32 bits dessus. Je te tiens au jus, mais ce ne sera pas ce soir ... Wink

Doc:

... je vais me croire au boulot ... ^^. Bon après hein, c'est bien parce qu'il y a de l'asm68k et que ca me rappelle des souvenirs ... Mr. Green

par Invité Mar 17 Fév 2015 - 22:27

Y a pas le feu au lac !!
Te prends pas la tête, rien ne presse, c'est du loisir !

par tfdi Mer 18 Fév 2015 - 14:15

Bon, j'ai récupéré un Windows XP sur une machine virtuelle, l'assemblage fonctionne, j'ai plus qu'à voir ca.

En passant, y a quelqu'un qui pourrait m'indiquer un émulateur Megadrive avec debuggueur intégré (si ca existe?) ?

Sur Atari on a Steem Debug, un équivalent mais pour la Megadrive ?... Very Happy

Vetea:Les fichiers Raw, c'est bien du Stéréo PCM 8 Bits unsigned à 11025 Hz ? J'ai l'impression de ne pas avoir la bonne vitesse, y a une modif à faire sous Audacity pour la vitesse de lecture ?

par Invité Mer 18 Fév 2015 - 14:31

Oui ce sont bien des RAW 8bits à 11025Hz.
Voici un émulateur avec un debug intégré Gens KMOD :
http://segaretro.org/Gens_KMod

par Stef Mer 18 Fév 2015 - 15:07

Mono, pas stéréo Wink

par tfdi Mer 18 Fév 2015 - 16:53

Heu... chuis fatigué ou on ne peut pas tracer le code avec Gens_Kmod ? Si c'est possible, quelqu'un peut m'expliquer vite fait ?

Si ce n'est pas possible, y a un débuggueur ou on peut tracer l'intégralité d'une rom ?

Stef:Merci de la précision :) ...

Je cherche aussi des docs techniques développeur sur la MD, si quelqu'un a un ou des liens, parce que j'ai beau chercher, je ne trouve rien de vraiment "précis".

Je cherche entre autre les adresses $A00000 (à priori, ram du Z80, mais elle fait quelle taille exactement? Jusqu'à $A0FFFF soit 64 ko ?), à quoi sert exactement l'adresse $A11100 et l'adresse $A11200 ?

par Invité Mer 18 Fév 2015 - 17:39

L'address Map de la MD :
http://en.wikibooks.org/wiki/Genesis_Programming

$A11100 = Bus Request, on va communiquer par le biais de cette adresse avec le Z80.
$A11200 = Bus Reset : RAZ du Z80

L'espace mémoire du Z80 : $A00000 - $A0FFFF

Concernant le mode Debug de Gens Kmod, tu as un onglet Debug avec differentes options ( 68K, Z80, VRAM, etc ... )

par Stef Mer 18 Fév 2015 - 17:43

Tu as la doc complète et officielle ici :
http://xi6.com/files/sega2f.html

La ram du Z80 commence à $A00000 et fait 8Ko (donc jusqu'à $A01FFF).
L'adresse $A11100 permet de "requester" le BUS du Z80 à partir du 68000 et l'adresse $A11200 permet de faire un reset sur le Z80 (et le YM2612). La documentation que j'ai mis en lien explique assez bien le principe.

par tfdi Mer 18 Fév 2015 - 18:13

Veta:Oui ca j'ai bien vu l'onglet debug :) ... je parle de pouvoir TRACER le code du 68000 et du z80, c'est ca que je n'ai pas trouvé. Afficher le contenu des registres en temps réel, j'en vois pas vraiment l'utilité si on ne peut pas au minimum tracer le code, d'où ma question. Je n'ai pas la faculté de "voir" des milliers d'operations / seconde en temps réel ... ^^

Merci pour le lien de la doc, mais celle là n'est pas précise du tout, je l'avais trouvé.

On prend un exemple simple, en $A11200, c'est indiqué Z80 reset. Ils ont juste oublié d'indiquer qu'est ce qu'il fallait "écrire" à cette adresse pour effectuer le reset du Z80. Autrement dit, ben ca sert pas à grand chose. Tu sais que l'adresse permet de faire un reset du Z80, mais tu ne sais pas comment ... Mr. Green

.

Par contre, le lien de Stef est mieux documenté, on sait qu'en tapant un 0 sur $A11200, on envoi une requete de RESET au Z80, et qu'en envoyant 1, on peut annuler cette requête Wink

. C'est ce genre de doc que je cherche, merci :)

par Stef Mer 18 Fév 2015 - 18:22

Perso pour tracer l'exécution j'utilise mon bon vieux emulateur Gens 2.11 (la version classique).
Au moins avec je sais comment on trace le code, 68000 comme z80 (touche T pour exécuter une instruction par exemple mais il y a pleins de touches utiles).

par tfdi Mer 18 Fév 2015 - 18:45

Concrètement, j'ai pris Gens2.12 (classique), quand je charge une rom, il l'exécute directement, ce qui fait qu'évidemment, je n'ai pas le temps de voir quoi que ce soit.

Comment faire pour qu'il n'execute pas la rom directement, et pouvoir la tracer dès la premiere ligne de code ?

Ca peut paraitre c** ... mais je n'ai rien vu au niveau des menus.

par dub Mer 18 Fév 2015 - 19:01

J'ai jamais testé le debug sous megadrive mais tu peux tester ce site :
http://www.romhacking.net/?page=utilities&category=&platform=11&game=&author=&os=&level=&perpage=20&title=&desc=&utilsearch=Go

debugens
Gens tracer

Ou alors avec mess aussi
[ TERMINE ] - Papi Commando Megadrive Edition ! - Page 8 10h59pd

[ TERMINE ] - Papi Commando Megadrive Edition ! - Page 8 10h59pd

https://2img.net/h/oi41.tinypic.com/10h59pd.png

par dub Mer 18 Fév 2015 - 19:34

Avec Mess, j'ai un trace en temps réel de Monster world 4.

Alors ce que tu fais, tu lances en ligne de commande :

mess megadriv -cart nomdufichier.bin -debug

voili voilou, ça marche peut être avec mame, mais pas testé.

Sinon, si tu passes par une interface genre messui, tu as dans les propriétés un onglet debug, avec un activate integrated debugger.

Ah oui, après il faut aller dans le menu debug et choisir "Run to next CPU" pour aller sur le Z80