Archives pour la catégorie retrogaming

Un peu de délire

Publié le par
Répondre
En 1992, un jeu d’un nouveau genre est apparu sur nos écrans. Un jeu que l’on pourrait qualifier de jeu « Online visiophonique » !
Le principe de l’émission était simple, un jeu vidéo pour attirer les geeks en herbe et une présentatrice sympathique (la très sexy Karen Cheryl) pour faire grimper un peu plus l’audience.
Dans sa première version, le principe du jeu est plutôt basique, il s’agit de diriger le personnage via les touches 4 et 6 de son téléphone. Nous allons donc voir comment recréer facilement ce système de contrôle. Cette émission se nommait « Hugo Délire ».

Karen

Comment ça marche ?

Grace au DTMF (non ce n’est pas la dernière insulte à la mode mais plutôt l’abréviation de dual-tone multi-frequency ou fréquences vocales pour les français), on peut savoir sur quelle touche la personne appuie en fonction de la fréquence sonore et diriger ainsi le personnage en fonction.

DTMF

Mise en oeuvre

Il faut :
1 – Arduino UNO.
1 – Décodeur DTMF MT8870 .
1 – Ligne téléphonique avec un téléphone.
1 – Un PC avec le jeux Hugo et l’émulateur qui va bien (le jeux original tournait sur Amiga mais par souci de facilité j’ai utilisé la version PS1).
On connecte donc l’écouteur du téléphone au décodeur DTMF qui lui même est connecté à l’Arduino qui est lui même connecté au PC.

Montage

On relie donc :

– L’écouteur du téléphone au module DTMF via une prise jack (n’ayant pas de ligne fixe j’ai utilisé un portable, l’Iphone de droite).
– Le module DTMF a l’Arduino (STQ -> 5, les pins 1,2,3,4 vers leur homologues sur .l’arduino)
– l’Arduino en USB au PC

Setup

Voici le lien vers le code Arduino qui utilise UnoJoy pour que l’arduino soit reconnu comme un Joystick afin de l’utiliser dans l’émulateur.
Il ne reste plus qu’a lancer le jeu, appeler la ligne téléphonique en question et jouer 🙂

Restauration d’un flipper : Part 1

Publié le par
Répondre

Depuis deux ans j’ai récupéré un flipper Staal Gunmen, une machine made in France de 1979. Comme beaucoup de choses que je récupère il ne fonctionne pas et est en mauvais (très mauvais) état.

Au boulot !

Commençons par le fronton (partie supérieure du flipper qui affiche le score). Chose étrange, le bois utilisé pour le flipper est du contreplaqué couvert d’une épaisseur (5 mm) d’aggloméré sur lequel il y a la peinture. Comme il n’a pas été entreposé dans un endroit sain, l’agglo s’est dégradé et ne semble pas récupérable.

fronton

On emploie alors les grands moyens et on fait sauter la couche d’agglo et on la remplace par du contre plaqué de 5 mm. Après de longues heures de travail, pas mal de colle, de pâte à bois et quelques coups de rouleaux de peinture le résultat est plutôt satisfaisant.

fronton_new

Il reste à faire les décors mais ce sera pour plus tard.

Un peu d’arduino

Je souhaite réutiliser au maximum les éléments d’origine, mais malheureusement sur ces flippers les cartes mères ont tendance à lâcher à causse des CPU de mauvaise qualité… Donc pas le choix, il faut tout refaire avec les moyens du bord. Sur le fronton les afficheurs 7 segments utilisent des circuits assez standard j’ai donc pu les faire tourner sans problème avec un arduino. Bien sur tout le code sera disponible sur mon github.

afficheur.jpg

Aux pieds !

Comme je le disais plus haut les flippers et l’humidité ne font pas bon ménage, les pieds sont assez fatigués …Les voici après un petit coup (quelques heures) de grattage intensif.

Il ne reste qu’a les lustrer pour que ça brille …

 

 

 

Développer sur Méga Drive : Part 2

Publié le par
Répondre

Comme précisé dans le dernier articles nous allons parlé ici de Debug et de JoyPad.

Debug

C’est un peu la base quand on développe de pouvoir debugger son programme afin de savoir ce qu’il se passe et pouvoir résoudre d’éventuels problèmes. Le SDK fournis tout le nécessaire pour débugger en alliance avec Gens KMod (menu CPU->Debug). Il y a différents items dans le menue permetant de voir pas mal de choses (registres des cpu, video, son, …). Nous allons utiliser la méthode la plus simple, les messages; elle permet simplement d’envoyer des messages dans une console un peu comme si vous utilisiez des « printf ». Pour cela c’est très simple il suffit d’utiliser la fonction KDebug_Alert qui prend en paramètre un string et le tour est joué (ne pas oublier le #include <kdebug.h> pour inclure les entêtes de debug).

 

#include <genesis.h>
 #include <kdebug.h>
 
 int main()
 {
 
        VDP_drawText("GENESIS HELLO !", 1, 1);
        KDebug_Alert("debug genesis hello");
 
        while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

 

Une fois la rom chargée, en allant dans CPU->Debug->Messages nous voyons notre magnifique message de debug apparaître, facile mais très utile.

debug_1

 

JoyPad

Passons maintenant aux contrôles. Le JoyPad de base avait 3 boutons (A B C), un bouton start et une croix directionnelle puis il y a eu ensuite une version avec 6 boutons et d’autres type de contrôleurs (souris, clavier, pistolet…) qui sont aussi géré par le SDK. La capture des événements se fait pas un callback que l’on défini dans le main avec la fonction JOY_setEventHandler(nom_de_la_fonction_de_callback).  Cette fonction prend trois paramètres (u16 joy, u16 changed, u16 state) :

  • joy étant le joypad utilisé (JOY_1, JOY_2, …)
  • changed définie si un bouton a été pressé
  • state définie si un bouton à été relâché

 

Petit code pour mieux comprendre ….

 

#include <genesis.h>
 #include <kdebug.h>
 
 
 void handleJoyEvent(u16 joy, u16 changed, u16 state)
 {
    KDebug_Alert("joy callback");
    if (joy == JOY_1)
    {
        if (state & BUTTON_UP)
        {
            KDebug_Alert("up press");
        }
        else if (changed & BUTTON_UP)
        {
            KDebug_Alert("up rel");
        }
    }
 }
 
 
 int main()
 {
 
 
        JOY_setEventHandler(handleJoyEvent);
 
 
        VDP_drawText("GENESIS HELLO !", 1, 1);
        KDebug_Alert("debug genesis hello");
 
        while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

 

Le résultat

 

debug_2

Fin de cette deuxième partie…. Dans la suite nous parlerons de l’affichage.

 

Développer sur Méga Drive : Part 1

Publié le par
Répondre

Ceux qui me connaissent savent que j’apprécie les jeux vidéo, surtout les « vieux » jeux, et plus précisément les jeux et les consoles de la marque SEGA et je suis tombé il y a peu sur un SDK (Software Development Kit) permettant de développer facilement (en C) des applications pour la Mega Drive.

Je ne pouvais donc pas passer à côté sans jouer avec et j’en profite pour écrire quelques articles sur le sujet.

Présentation

La Mega Drive (Genesis aux US), est une console 16bits de SEGA sortie fin 1988 au japon, pour connaître son histoire je vous invite à lire sa page sur wikipedia.

Elle possède un CPU principal Motorola 68000 (7.6Mhz) et un coprocesseur Z80 (3.58Mhz)  très souvent utilisé pour gérer la partie son et qui permet aussi une rétrocompatibilité totale avec les jeux Master System le tout agrémenté de 64Ko de RAM (dont 32 accessibles par le Z80).

Au niveau vidéo, le VDP (Video Display Processor) permet d’afficher avec des résolutions de 320×224 et 256×224 (ou 320×240 et 256×240 pour les versions PAL), nous reviendrons en détail sur la partie vidéo plus tard.

Prérequis

  • Le SDK, récupérer les sources sur ce dépot git et les compiler.
  • Un éditeur de texte, Vim est parfait pour ça.
  • Gens KMod qui est une version de l’émulateur modifié avec pas mal d’options de debug (fonctionne très bien sous linux avec Wine).

On se lance dans le premier programme

Comme tout le monde nous allons faire un petit « Hello Wolrd » que nous enrichirons au fur et à mesure de notre apprentissage.

#include <genesis.h>

int main()
 {

       VDP_drawText("GENESIS HELLO !", 1, 1);

       while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

Petite analyse du code :

  • L’inclusion du début permet de charger les entêtes des librairies fournies par le SDK.
  • VDP_drawText sert a afficher du texte suivant les coordonnées X et Y données ensuite.
  • Le while sert juste a avoir une boucle qui tourne dans laquelle nous pouvons faire plusieurs choses (lire les informations du joypad, mettre à jour des variable, modifier l’affichage …) et surtout on y met dedans le VDP_waitVSync qui permet de caler la boucle sur le rafraîchissement de l’affichage de la console 50Hz en PAL et 60Hz en NTSC.

Plus qu’a compiler notre programme avec le Makefile fournis dans le SDK pour simplifier les choses :

make -f /opt/gendev/sgdk/mkfiles/makefile.gen

La compilation nous crée deux répertoires à la racine du projet. Le premier est nommé src dans lequel on retrouve deux fichiers :

– rom_head.c qui contient les métadonnées concernant la rom (Copyright, Nom, Zone…).

– sega.s qui lui comprends le code nécessaire au boot du programme sur la console.

Dans le dossier out nous trouvons les fichiers objets (.o) et les binaires résultants de la compilation. Celui qui nous intéresse est le fichier rom.bin qui est la rom de notre programme.

Il ne reste plus qu’à l’ouvrir dans un émulateur pour voir le résultat.

Dans la prochaines partie nous verrons comment récupérer les information d’un joypad et comment débugger simplement ses programmes.

 

UNOJOY, l’ami des Arduino et des arcades ?

Publié le par
Répondre

J’avais depuis quelques temps une borne Sega Rally qui trainait dans un coin (oui le gros truc avec les sièges et volant). Après de multiples tentatives de réparation j’ai opté pour une solution simple mais efficace, vider le tout et mettre un PC avec des émulateurs et des jeux.

sega-rally-twin-sit-down-racing-arcade-machine

Avantages :

  • Alléger le tout
  • Pouvoir jouer à plein de jeux

Inconvénients :

  • Perte du retour de force
  • Beaucoup de travail
  • Se faire huer par les puristes

J’ai donc commencé par tout désosser, remplacé les écrans par des écrans LCD, refait les parties bois, tout repeint … Vient alors le moment de remonter la borne et de tout câbler. Pendant toutes ces étapes une question restait alors sans réponse… que faire pour le volant. J’ai pensé utiliser un volant du marché mais souhaitant conserver au maximum le design de la borne cela n’allait pas, et un jour je suis tombé sur UNOJOY.

UNOJOY permet de transformer son Arduino en Joystick en utilisant les entrées analogiques et numériques, ceci est tout simplement génial.

UNOJOY fonctionne sur Arduino Uno, Mega et Leonardo; en gros ça reprogramme l’atmega 8U2 ou 16U2 (suivant la carte utilisée) pour faire reconnaître l’Arduino comme un joystick par le PC (mais apparement aussi la ps3).

windows

Avant cette étape il faut bien sûr câbler le tout et vérifier que ça fonctionne, pour cela un petit outil Processing permet de voir en live si les contrôles fonctionnent bien.

processing

En cas de contrôles un peu plus complexe (comme la boîte de vitesse sur ma borne) il est possible d’adapter le code (UnoJoyArduinoSample.ino) afin de gérer ces contrôles.

vitesses

Voici le petit hack pour utiliser mon levier à 4 vitesses avec trois Switchs qui sont connectés sur les pins numérique 2, 3 et 4 :

controllerData.triangleOn = LOW;

controllerData.circleOn = LOW;

controllerData.squareOn = LOW;

controllerData.crossOn = LOW;

  

//  operator to invert the readings from the pins

if (!digitalRead(2)&& digitalRead(3))

  controllerData.triangleOn=HIGH;

else if (!digitalRead(3) && !digitalRead(4))

  controllerData.circleOn=HIGH;

else if (!digitalRead(3))

  controllerData.squareOn=HIGH;

else if (!digitalRead(4))

   controllerData.crossOn=HIGH;  

On envoie ensuite le code sur l’Arduino, puis on lance le petit bat qui le transforme en périphérique de jeux et le tour est joué. Il est bien sûr possible de transformer à nouveau sa carte en Arduino avec un autre bat.

Je vous ferai découvrir très prochainement une réalisation utilisant UnoJoy, « stay tuned » comme on dit !

Le code de UnoJoy : https://github.com/AlanChatham/UnoJoy