Bonjour,
 
J’ai récemment acquis la dernière version du INLretro programmer/dumper (également connu sous le nom de « Kazzo ») sur le site http://www.infiniteneslives.com/inlretro.php
Pour ceux qui ne connaissent pas, il s’agit d’un PCB permettant de lire et d’écrire (a priori uniquement sur des cartes spécifiques) des cartouches de jeux de différentes consoles anciennes.
Pour ma part, j’ai pris la version avec tous les ports disponibles : Famicom, NES, Super Famicom, SNES, N64, Megadrive/Genesis, GameBoy, GBA.
Voici la bête :

Mon objectif principal est de copier (dumper) des jeux de ma collection pour les sauvegarder et pouvoir y jouer confortablement sur émulateur ou, mieux, sur console FPGA.
Je suis également curieux de comparer les versions des jeux qui étaient commercialisées en France (sous le code FRA pour la NES) avec les roms PAL que l’on peut trouver ici ou là sur Internet et qui sont le plus souvent des version EU voire Word.
La difficulté est que le projet INLretro est loin d’être finalisé au plan du software et que je ne trouve pratiquement rien (voire, rien du tout) d’utile à ce sujet sur Internet.
Je souhaite donc partager mon expérience au fur et à mesure dans l’espoir que cela puisse servir à d’autres et, par la même occasion, profiter de l’aide de ceux qui voudront bien l'apporter, pour pouvoir progresser.
Je précise que je suis pratiquement novice en la matière et que je suis loin d’avoir les connaissances software et hardware qui permettraient d’exploiter pleinement l'appareil mais, en bidouillant un peu, je suis arrivé à des résultats et suis en mesure de proposer des solutions qui fonctionnent.
Toutes les remarques ou corrections/suggestions seront les bienvenues !
 
Pour commencer, je vais expliquer les points suivants :
- Comment installer le driver pour faire fonctionner l'appareil sous Windows.
- Comment connaître le mapper du jeu à dumper (ou l’absence de mapper) : j'expliquerai grossièrement ce qu'est le mapper.
- Comment dumper une cartouche NES qui ne comporte pas de mapper (ex. : Super Mario Bros.).
- Comment générer une ROM à partir du fichier binaire issu du dump.
 
1) Installation du driver sous Windows
J’ai testé sous Windows 7 et Windows 10 et cela a fonctionné sans aucun problème.
Il faut commencer par se rendre sur le dépôt Gitlab du projet : https://gitlab.com/InfiniteNesLives/INL-retro-progdump
Puis télécharger le contenu du dépôt.
Ensuite, il faut brancher la carte INLretro à un PC au moyen du câble USB fourni (le câble fourni est très court mais vous pouvez utiliser un câble plus long si vous en avez).
Après vous être assuré que l’interrupteur de la carte est en position « RUN », il faut lancer l’exécutable « InstallDriver.exe » qui se trouve dans le répertoire « INL-retro-progdump/WindowsDriverPackage/ ».
Une fois l’installation du driver terminée, la carte est prête à être utilisée.
Nota : je n’ai pas eu à redémarrer le PC mais il est peut-être préférable de le faire au cas où.
 
2) Déterminer le mapper du jeu à dumper (ou l'absence de mapper)
Qu’est-ce qu’un mapper ? Il s’agit d’un composant électronique (une puce, en général) qui est présente sur la plupart des cartouches NES et dont la fonction est de faire interface entre les données de la cartouche et la console, sans que cette dernière ait à se soucier de l’architecture spécifique de la cartouche.
A l’origine, les premières cartouches NES ne comportaient pas de mapper. Mais pour étendre les possibilités des jeux, les concepteurs ont dû complexifier et perfectionner l’électronique de celles-ci. Pour que la console puisse prendre en charge ces nouvelles architectures sans devoir être modifiée, un composant électronique a été ajouté, qui permet de présenter les données à la console d'une manière qu’elle est capable d'exploiter.
L’architecture des cartouches ayant continué à évoluer, différents types de mappers ont été conçus au fil du temps. Il en existe donc un certain nombre...
Déterminer le mapper spécifique d’une cartouche (ou l’absence de mapper, pour les jeux les plus anciens) est une étape essentielle pour pouvoir lire et copier les données binaires d’un jeu. Le INLretro a besoin de savoir quelle logique utiliser pour accéder aux données du jeu.
Comment obtenir cette information ? En cherchant sur Internet. Pour m’a part, je me réfère à la liste disponible à l’adresse suivante : http://tuxnes.sourceforge.net/nesmapper.txt
Pour le moment, je n’ai pas été confronté à un jeu qui n'y figure pas.
La connaissance du mapper sera également indispensable pour pouvoir générer une ROM à partir du fichier binaire contenant le jeu, afin de le faire tourner sur émulateur (nous y reviendrons par la suite).
 
3) Dumper une cartouche NES sans mapper
Il est temps de dumper notre première cartouche !
Nous allons prendre pour exemple Super Mario Bros. version PAL FRA.
En se référant à la liste nesmapper.txt dont j’ai déjà donné le lien, on obtient les informations suivantes :

Mapper (0) signifie que la cartouche ne comporte pas de mapper, ce qui se conçoit s’agissant de l’un des tous premiers jeux de la console, sorti en 1983 au Japon et 1986 en Europe.
A l’heure actuelle, pour pouvoir faire fonctionner le INLretro, il faut utiliser un script LUA (INL-retro-progdump/host/scriptsinlretro.lua) en ligne de commande (via CMD sous Windows).
Il n’y a pas encore d’interface graphique à ce stade mais c’est semble-t-il prévu dans le futur.
Il faut, au préalable, modifier certaines parties du script pour lui faire effectuer l’action désirée (choix de la console, choix du mapper, tâche à effectuer, etc.).
La difficulté est que les développeurs n’ont semble-t-il pas prévu la possibilité de lire des cartouches sans mapper, celui-ci devant être spécifié (ou alors je n’ai pas trouvé l’option correspondante).
Il faudra donc écrire notre propre script en utilisant les modules disponibles. Mais pas de panique ! Cela va être très simple.
Nous pouvons créer un nouveau fichier .lua dans le répertoire « scripts », par exemple : inlretro.nes.nomapper.lua. Il s'agit d'un simple fichier texte a éditer avec son logiciel favori (Notepad++, pour ma part).
Voici le script proposé :

Je ne suis pas certain que les modules inclus en entête soient tous absolument nécessaires en l'occurrence (peut-être pourrait-on se passer du module app.cart). A voir...
Une fois le fichier contenant le script enregistré, il reste à placer la cartouche dans le bon slot (la face avant de la cartouche doit être orientée vers l’interrupteur « RUN » de la carte, du côté où figure l’inscription « NES CARTIDGE FRONT SIDE » sur le PCB).
Ensuite, un petit reset par sécurité (au moyen du petit bouton-poussoir juste à côté de l’interrupteur « RUN »).
Il reste à exécuter le script avec la commande suivante :

Si tout s’est bien passé, vous devez avoir un fichier dump.bin d’environ 40 Ko (et oui, c’est tout petit).
Il s’agit des données binaires du jeux. Il ne peut pas être exécuté tel quel dans un émulateur. Pour cela, il va falloir lui ajouter un entête (si si, entête est un mot masculin; ROM devrait l'être aussi d'ailleurs...). Nous allons voir comment le faire à présent.
 
4) Générer une ROM à partir du fichier binaire issu du dump
Le fichier .bin obtenu à l’issu du dump contient les données binaires du jeu. Un émulateur n’a a priori aucun moyen de déterminer l’architecture spécifique de la cartouche dont il est issu, ni le mapper à utiliser pour l'émuler et faire fonctionner le jeu.
C’est à nous de lui fournir ces informations. Pour se faire, il faut ajouter un entête (header) au fichier binaire. Cet entête va contenir les informations nécessaires pour permettre à l'émulateur de remplir sa tâche.
Il existe deux formats d’entêtes pour les ROM NES : iNES et NES 2.0.
Nous allons utiliser le format iNES. Il s’agit simplement de 16 bytes de données qui vont être ajoutées au début du fichier et prendre des valeurs spécifiques en fonction de la cartouche à émuler.
Pour se faire, j’utilise un petit logiciel très pratique : NESHEAD (disponible ici : https://www.romhacking.net/utilities/665/).

 
Une fois NESHEAD téléchargé et lancé, nous allons nous en servir pour générer l’entête nécessaire.  
Reprenons les informations du jeu trouvées dans le fichier nesmapper.txt :

La cartouche ne comporte pas de mapper, il faut donc laisser le champ « Mapper » à 0
La cartouche comporte 32k de PRG-ROM, soit 2 pages de 16k : il faut donc spécifier 2 dans le champ « PRG 16k Count ». Et 8k de CHR-ROM, soit 1 page : il faut donc spécifier 1 dans le champ « CHR 8k Count ».
Le « Mirroring » est V pour Vertical.
Voilà, notre entête est prêt, il ne reste plus qu’à l’ajouter au fichier dump.bin.
Nota : dans le test que j’ai effectué, je n’ai pas coché la case « PAL ». Ensuite j’ai eu l’impression que le jeu était plus rapide qu’à la normale dans l’émulateur. Peut-être est-il préférable de cocher la case pour que l’émulateur sache qu’il doit faire tourner le jeu en 50hz et non en 60hz. Si quelqu'un veux bien tester avec et sans PAL, je serais curieux de savoir ce qu’il en est.
Pour ajouter l’entête à notre fichier binaire, il faut aller dans le menu File/Save/Insert to binary. Il reste ensuite à sélectionner le fichier dump.bin et à enregistrer.
Le fichier peut à présent être renommé comme on le souhaite, avec l’extension .nes. Par exemple : Super Mario Bros. (E) [!].nes (le [!] est bien mérité, non ?!).
Voilà, il ne reste plus qu’à lancer la ROM dans son émulateur préféré (FCEUX, pour ma part).
 
Bonus : j’ai effectué une comparaison binaire entre la ROM obtenue et les ROMs Europe et World présentes sur Internet. Résultat : notre ROM et la version Europe sont strictement identiques, au bit près. En revanche, il y a de petites différences avec la version World. Mais je ne sais pas les interpréter. Si quelqu'un en est capable, je serais curieux de savoir ce qu'il en est ! Je n'ai pas noté de différences visibles sur émulateur.
 
Prochain tutoriel : comment dumper une cartouche avec mapper MMC1.
To be continued...

Dans un précédent tutoriel, nous avons vu comment dumper une cartouche NES sans mapper (Super Mario Bros. PAL FRA, en l'occurrence) à l’aide du INLretro programmer/dumper (également connu sous le nom de « Kazzo ») de www.infiniteneslives.com.
Je ne garantis pas qu’il s’agisse de la méthode la plus « élégante » pour le faire mais en tous cas, elle a fonctionné parfaitement pour moi.
A présent, nous allons voir comment dumper une cartouche avec mapper MMC1 et générer une ROM jouable sur émulateur. Nous allons prendre pour exemple une cartouche Double Dragon PAL FRA.

Nota : si vous n’avez pas déjà effectué les premières étapes expliquées dans mon premier post (téléchargement des fichiers, installation du driver, etc.), je vous invite à vous y référer au préalable et à revenir en suite.
 
En consultant le fichier http://tuxnes.sourceforge.net/nesmapper.txt on constate que les caractéristiques techniques de la cartouche sont les suivantes :

Le mapper est bien MMC1.
Nous n’allons pas pouvoir réutiliser le petit script que j’avais écrit pour dumper les cartouches sans mappeur tel quel. Si nous le faisions, le INLretro ne saurait pas commencer accéder aux données du jeux et se contenterait de dumper quelques kilooctets qui s’avéreraient totalement inutiles.
A ce stade du projet INLretro, le mapper MMC1 est bien pris en charge et nous allons pouvoir utiliser le script inlretro.lua que nous avons déjà téléchargé (il se trouve dans le répertoire INL-retro-progdump/host/scripts/).
Mais nous allons devoir l’adapter pour qu’il fasse ce que nous voulons. Nous devrons aussi retoucher le fichier mmc1.lua présent dans INL-retro-progdump/host/scripts/nes/
Dans le fichier inlretro.lua, il faut modifier les lignes suivantes :
1) Vers la ligne 69, mettre le code suivant en commentaire :

De cette manière :

Et décommenter la ligne au-dessus :

 
2) Vers la ligne 275, sous « --MMC1 », ajouter le code suivant :

 
Après cette étape, si nous exécutons le script, nous obtiendrons un fichier dump.bin de 384 ko. Si nous ajoutons un entête et lançons la ROM obtenue sur émulateur, nous aurons une bouillie de pixels !  
La raison en est qu’en réalité, la taille du jeu n’est pas de 384 ko mais de 256 ko (128k de PRG-ROM + 128k de CHR-ROM, comme nous l’avons vu dans la liste nesmapper.txt).
Pour une raison qui m’échappe, la taille de la PRG-ROM et de la CHR-ROM a dumper est fixée de manière invariable dans le script mmc1.lua, aux lignes 176 et 177 :

 
J’en ignore la raison ; peut-être cela est-il lié aux caractéristiques des cartes NES flashables vendues par infiniteneslives.com.
En tous cas, pour pouvoir dumper correctement le jeu, nous allons devoir modifier la taille de la PRG-ROM :

 
La taille de la CHR-ROM correspond bien quant à elle à celle de Double Dragon et n’a donc pas à être modifiée.
Bien sûr, si vous essayez de dumper une autre cartouche avec mapper MMC1, il faudra vous assurer que les deux tailles correspondent bien à votre cartouche.
Une fois le script mmc1.lua modifié, nous pouvons lancer inlretro.lua avec la commande suivante :

 
Le résultat devrait être un fichier dump.bin de 256 ko.
Reste à présent à passer à la dernière étape : générer l’entête de la ROM.
Pour cela nous allons utiliser NESHEAD avec les options suivantes :

Après avoir inséré l’entête dans le fichier .bin et l’avoir renommé en .nes, la ROM se lance parfaitement dans l'émulateur de votre choix.
 
Nota : attention, si vous n’êtes pas habitués à ce jeu, vous pourriez appuyer frénétiquement que le buton Start et les boutons A et B sans que rien ne se passe, et en déduire que la ROM ne fonctionne pas. En réalité, il faut commencer par appuyer sur le bouton Select pour choisir le mode de jeu, puis sur Start.
 
Bonus : si l’on compare bit à bit la ROM obtenue avec la version Europe du jeu présente sur Internet, on constate qu'il n’y a strictement aucune différence. Et avec la version USA... Il n’y a aucune différence non plus ! Le jeu semble être exactement le même dans les deux régions (sauf sans doute pour la fréquence de rafraîchissement).

Après les deux précédents tutoriels pour dumper des cartouches de jeux NES, je mets de côté cette console pour m’intéresser à… la Megadrive/Genesis !
Je testerai plus tard les autres mappers de la NES (sachant qu'ils ne sont pas encore tous supportés).
 
A présent, je souhaiterais mettre à partie mon INLretro programmer/dumper pour copier ma collection de jeux Megadrive et la convenir en ROMs. J’espère être prêt lorsque sortira la nouvelle console FPGA d’Analogue Mega Sg (et sera « jailbreakée » rapidement, je l’espère), afin de pouvoir jouer à mes jeux sur carte SD pour plus de facilité et de confort.
Le souci est qu’à ce stade du projet INLretro, il ne semble y avoir aucun support logiciel pour les cartouches de Sega : les sections de code correspondantes du script inlretro.lua sont vides pour le moment, il n’y a aucun script dédié dans le répertoire INL-retro-progdump\host\scripts\app\
 
Cependant, il y a bien un bloc de code consacré à Sega dans le dict.lua et le script dump.lua contient une fonction dumptofile() qui semble générique et que je pourrais peut-être utiliser pour tenter quelque chose.
Mais mes compétences en la matière sont très limitées et je me demande si quelqu’un pourrait m’aider ou au moins m’orienter pour trouver un point de départ.
La fonction en question prend les variables suivantes : file, sizeKB, map, mem, debug
Pour la taille du dump (sizeKB), je ne sais pas si je pourrais trouver un moyen de ne pas avoir à la spécifier et de dumper toutes les données de jeu présentes sur une cartouche.
Pour la variable « map », il semble qu’elle renvoie à un mapper. J’ai entendu dire que les cartouches Megadrive n’ont pas de mapper (ou alors qu’il est toujours le même ?).
La variable « mem » semble être utilisée pour paramétrer des buffers ; je n’ai aucune idée de comment la spécifier ou la manipuler.
Dans l’absolu, je ne sais même pas si je pourrais réellement me servir de cette fonction pour dumper des cartouches Megadrive/Genesis…  
 
Vous remerciant d’avance pour votre aide.

Bon, je crois que c'est "rappé" pour le moment pour les cartouches Sega. Je me suis penché sur les sources du Firmware et j'ai bien l'impression que le support Sega est embryonnaire voire quasi inexistant..
J'ai essayé de faire juste un dict.io("SEGA_INIT" ) pour voir et voilà le résultat :
 

 
Quelqu'un saurait-il comment coder un Firmware par hasard ?!
Quel dommage d'avoir autant de slots et de ne pas pouvoir s'en servir. C'est un peu frustrant...