Collegare un joypad SNES al PC

Un vecchio joypad per Super Nintendo può essere riesumato e riportato in vita con qualche piccola modifica per essere usato come joypad per PC. Essenzialmente si tratta di costruire una piccola interfaccia per poterlo collegare alla porta parallela, e poi usarlo come normale joypad tramite alcuni appositi driver liberamente scaricabili su internet (più sotto trovate i link).

Dato che trovo il joypad dello SNES molto comodo da usare, ho deciso di modificarlo ed adattarlo al mio computer per usarlo con vari emulatori (dello SNES e non) e videogiochi vari.

Quello che occore:

  • saldatore a punta fine da almeno 25 Watt
  • stagno fino, meglio se con anima all’acido disossidante
  • un connettore DB25 maschio (può esser recuperato da un vecchio cavo per stampante). Assicurarsi che non sia pressofuso, altrimenti non si potrà aprire facilmente e soprattutto non si potrà inserire la nuova circuiteria all’interno
  • un connettore a scelta tra: un connettore maschio USB, un connettore maschio per alimentatori per PC, un conettore maschio per porte joystick per PC; questo connettore servirà per alimentare il joypad e bisognerà scegliere il tipo in base alle proprie esigenze: se avete una porta USB sempre libera vi conviene il primo, se non ne avete ma possedete una porta joystick potrete optare per il terzo etc… io ho deciso di adottare il connettore maschio da collegare direttamente all’alimentatore del PC, perchè bene o male sono sempre presenti in tutti i tipi di PC (tranne i portatili ovviamente). Tutte e tre le porte forniscono una tensione stabilizzata di 5volt, in grado di erogare una corrente più che sufficiente per il joypad.
  • solita roba tra forbici e nastro isolante da elettricista

Un pò di teoria sul funzionamento originale del joypad

Il connettore originale del joypad si presenta così:

images

Data l’asimmetria della forma del connettore è impossibile sbagliarsi con la numerazione.

Questa è la descrizione dei sette pin:

pintable

I pin 5 e 6 non sono usati (non esistono nemmeno i fili corrispondenti all’interno del cavo del joypad). Il pin 1 serve all’alimentazione, mentre il 2,3 e 4 servono allo scambio dei dati, infine il pin 7 provvede a dare un riferimento di massa al joypad. Tutti i segnali ricevuti e inviati da o verso il joypad sono compatibili TTL (quindi 0volt per lo 0 logico e +5volt per l’1 logico). Ogni 1/60 di secondo la console invia al joypad sul pin 3 una segnale rect di 12 microsecondi; questa pulsazione istruisce il joypad a “congelare in memoria” lo stato dei suoi pulsanti per una imminente lettura che avviene appunto 6 microsecondi dopo, quando la console invia sul pin 2 un’onda quadra al 50% di duty-cycle formata da 16 pulsazioni alla quale il joypad risponde simultaneamente inviando sul pin 4 i dati relativi allo stato dei suoi pulsanti. La risposta va considerata come 16 bit ognuno dei quali riflette lo stato (premuto/non premuto) di un pulsante (in effetti i pulsanti sono solo 12, percui le ultime 4 pulsazioni non vengono considerate).

Tutto quello che va fatto e presentare tali segnali al PC tramite la parallela, anch’essa conforme allo standard TTL, ed usare un apposito driver per interfacciarsi con il sistema DirectX di Windows, a sua volta interfaccia di comunicazione per qualsiasi gioco esistente che supporti i joypad come input.

Schema dell’interfaccia

L’intefaccia, così come era stata pensata, prevedeva l’utilizzo di cinque diodi 1N4148 da collegare alle uscite della porta parallela, i catodi dei quali erano collegati tutti al pin 1 del joypad (cavetto bianco); Questo lo schema originario:

snes_interface

Essezialmente i pin 5,6,7,8 e 9, attraverso i diodi, fornivano la potenza (tensione da 5volt e qualche mA in uscita) necessaria al joypad per poter funzionare correttamente. Ho sperimentato comunque che questo approccio non funziona sempre, ma solo su schede madri in grado di erogare sufficiente corrente dai pin della porta parallela, con le altre il joypad può non funzionare del tutto. Il problema mi si è presentato notando che cambiando computer il joypad “misteriosamente” smetteva di funzionare.

Quindi, per rendere il joypad utilizzabile un pò dappertutto ho modificato lo schema in questo modo:

snes_interface2

I diodi sono stati eliminati del tutto (il che rende l’interfaccia ancora più semplice da costruire) e l’alimentazione viene ora fornita tramite i fili A (+5 volt) e B (massa comune). Tale tensione può essere prelevata o da una porta USB libera tramite apposito connettore, o dalla porta joystick oppure direttamente da un connettore dell’alimentatore interno del PC.

Costruzione dell’interfaccia

Per realizzare l’interfaccia si può procedere tagliando via con le forbici il vecchio connettore grigio del joypad, spellare i cinque fili avendo cura di verificare che i colori corrispondano alla numerazione dei pin data nella tabella precedente (alcune versioni dello SNES hanno colori differenti); nel caso non coincidessero è bene prenderne nota e riscrivere per bene le associazioni su un foglio di carta.

Bagnare con un pò di stagno le terminazioni in rame dei fili.

Fatto ciò aprite il connettore della parallela con un cacciavite piatto (svitando oppure facendo leva se è chiuso a pressione) ed iniziate a saldare i fili del joypad sui pin corrispondenti. I cavetti 2,3 e 4 del joypad vanno saldati rispettivamente ai pin 2,3 e 10 della parallela, mentre il pin 7 va collegato ai 18 e 19.

dsub25m

Passiamo all’alimentazione:

Realizzate un cavetto di circa 30 cm che presenti ad un capo un connettore a scelta tra USB (maschio), joystick (mascho) o d’alimentazione (maschio); spellate i fili all’altro capo ed individuate i fili dei +5v e di massa.
NOTA: La numerazione dei pin è effettuata mettendo di fronte il connettore.

USB

usb_a_b_female

pin 1 +5volt
pin 4 gnd

Joystick

dsub15m

pin 1 +5volt
pin 4 gnd

Alimentatore

molex_4p

pin 1 (rosso) +5volt
pin 2 o 3 (nero) gnd

Il filo dei +5v andrà sadato al pin 1 del joypad, mentre quello di massa con il pin 7 (e quindi anche con i 18 e 19 della parallela). Fate in modo che i due cavetti (quello del joypad e quello di alimentazione passino per il buco del connettore della parallela e chiudete il tutto assicurando con qualche giro di nastro isolante.

Non rimane che scaricare i driver per poter usare il joypad:

pad_driver

Ecco alcune foto del joypad modificato

snes2

 

snes1

Forza 4 in C

Forza4, il mitico gioco a turno dove occorre allineare 4 o più pedine in una scacchiera 6×7.

In questo articolo mostro come realizzare un IA abbastamza intelligente da poter giocare decentemente contro un avversario umano.

La grafica è completamente realizzata in ASCII, quindi niente di incredibile; quello che interessa è l’algorimo dell’IA e come esso è stato implementato: il minmax.

Minmax è una funzione di valutazione in grado di minimizzare (min) la massima perdita possibile e contemporaneamente massimizzare (max) il minimo guadagno. L’algorimo è applicabile a tutti i giochi a informazione completa come forza4, scacchi, dama, tris e in generale i giochi a turno.

L’algoritmo trova la mossa migliore esplorando tutto l’albero delle possibilità da quel punto del gioco in poi; in sostanza effettua una enorme quantità di simulazioni di gioco, provando tutte le prossime possibili mosse dell’avversario, tutte le possibili contromosse successive, tutte le possibili mosse successive dell’avversario e cosi’ via fino alla fine di ogni partita “simulata”. Ovviamente il numero dei possibili sviluppi di gioco aumenta esponenzialmente al numero delle mosse provate e quindi non è possibile esplorare completamente l’albero: occorre fermarsi prima.

500px-minimax.svg

Una realizzazione concreta proverà solo un ristretto numero di mosse in avanti terminate le quali verrà valutato in una scala opportuna il vantaggio del giocatore a quel preciso stato di gioco.

Codice sorgente: forza4

/* FORZA 4 - algoritmo DFS minimax */

#define SKILL 10
#define ROW 6
#define COLUMN 7

int board[ROW*COLUMN];
long int depth,skill;
unsigned long int nodes;

void display_board(void)
{
	long int i,j;
	printf("\n");
	for(j=0;j<ROW;j++)
	{
		for(i=0;i<COLUMN;i++)
		{
			if(board[i+j*COLUMN]==1) printf("X ");
			if(board[i+j*COLUMN]==-1) printf("O ");
			if(board[i+j*COLUMN]==0) printf(". ");
		}
		printf("\n");
	}
	for(i=0;i<(COLUMN*2)-1;i++) printf("-");
	printf("\n");
	for(i=0;i<COLUMN;i++) printf("%d ",i+1);
	printf("\n");
}

int checkwin(int player,int column,int lenght)
{
	long int j,r,l,i,height;
	lenght--;
	i = column;
	j = ROW-1;
	while(board[i+j*COLUMN]!=0) j--;
	j++;
	height = j;

	r = 0;
	l = 0;
	while(((++i)<COLUMN)&&(board[i+j*COLUMN]==player)) r++;
	i = column;
	while(((--i)>=0)&&(board[i+j*COLUMN]==player)) l++;
	if ((r+l)>=lenght) return 1;
	i = column;

	r = 0;
	while(((++j)<ROW)&&(board[i+j*COLUMN]==player)) r++;
	if (r>=lenght) return 1;
	j = height;

	r = 0;
	l = 0;
	while(((++i)<COLUMN)&&((++j)<ROW)&&(board[i+j*COLUMN]==player)) r++;
	i = column;
	j = height;
	while(((--i)>=0)&&((--j)>=0)&&(board[i+j*COLUMN]==player)) l++;
	if ((r+l)>=lenght) return 1;
	i = column;
	j = height;

	r = 0;
	l = 0;
	while(((++i)<COLUMN)&&((--j)>=0)&&(board[i+j*COLUMN]==player)) r++;
	i = column;
	j = height;
	while(((--i)>=0)&&((++j)<ROW)&&(board[i+j*COLUMN]==player)) l++;
	if ((r+l)>=lenght) return 1;

	return 0;
}

int extimated_value(int player)
{
	long int i,j,value,l;

	value = 0;
	for(l=2;l<4;l++)
	{
		for(i=0;i<COLUMN;i++)
		{
			if(checkwin(player,i,l)) value = value + l;
		}
	}

	return value;
}

int goodness(int player,int depth,int column,int trigger)
{
	long int max,i,value,j;
	max = -200;
	if (checkwin(-player,column,4)) return -128;
	if (depth==0) return 0;
	for(i=0;i<COLUMN;i++)
	{
		if(board[i]==0)
		{
			j = ROW-1;
			while(board[i+j*COLUMN]!=0) j--;
			board[i+j*COLUMN] = player;
			nodes++;
			value = -goodness(-player,depth-1,i,-max)/2;
			board[i+j*COLUMN] = 0;
			if (value>max) max = value;
			if (value>trigger) return max;
		}
	}
	return max;
}

int best_move(int player)
{
	long int i,j,max,value,best,same,trigger,old,att;
	long int res[COLUMN];
	max = -100;
	best = -1;
	for(i=0;i<COLUMN;i++)
	{
		if(board[i]==0)
		{
			nodes = 0;
			j = ROW-1;
			while((board[i+j*COLUMN]!=0)&&(j>=0)) j--;
			board[i+j*COLUMN] = player;
			value = -goodness(-player,skill,i,200);
			printf("\nmove %d goodness: %d   tree size for this move: %d nodes",i+1,value,nodes);
			res[i] = value;
			board[i+j*COLUMN] = 0;
			if (value>max)
			{
				max = value;
				best = i;
			}
		}
	}
	if(best==-1)
	{
		for(i=0;i<COLUMN;i++) if(board[i]==0) return i;
	}

	return best;
}

int main(void)
{
	int move,j,i,coins;
	coins = ROW*COLUMN;
	skill = SKILL-3;

	for(i=0;i<(ROW*COLUMN);i++) board[i] = 0;
	display_board();

	while(coins!=0)
	{
		if (coins==40) skill=SKILL-2; /* quick start */
		if (coins==36) skill=SKILL-1; /* improve skill level... */
		if (coins==34) skill=SKILL;   /* ...to maximum */
		do
		{
			printf("\nchoose column [1-%d]...",COLUMN);
			scanf("%d",&move);
			if(board[move-1]!=0) printf("\ncolumn is full");
		}
		while(board[move-1]!=0);
		move--;
		j = ROW-1;
		while((board[move+j*COLUMN]!=0)&&(j>=0)) j--;
		board[move+j*COLUMN] = 1;
		coins--;
		display_board();
		if(checkwin(1,move,4))
		{
			printf("\nYou win\n");
			return 1;
		}
		move = best_move(-1);

		j = ROW-1;
		while((board[move+j*COLUMN]!=0)&&(j>=0)) j--;
		board[move+j*COLUMN] = -1;
		display_board();
		printf("\nCPU move in %d",move+1);
		coins--;
		if(checkwin(-1,move,4))
		{
			display_board();
			printf("\nCPU wins\n");
			return 1;
		}
		printf("\n");

	}
	printf("\n");
	return 1;
}

Ecco l’output del programma durante una partita:

forza4

TapeRipper – Recuperiamo le vecchie cassette del C64

TapeRipper è un mio vecchissimo (parliamo del 2003) programma in grado di leggere le normali cassette dati del Commodore64 tramite apposita interfaccia registratore-PC e di generare il file .TAP corrispondente su hard disk. Il file .TAP puo’ quindi essere usato con un qualsiasi emulatore per C64 (tipo CCS64, VICE etc…).

Apparso sul numero 23 della rivista Hacker Journal

I requisiti minimi per far girare il programma fanno ormai sorridere, ma li metto lo stesso:

  • un PC IBM compatibile (dal 386 in su)
  • memoria almeno 4MB
  • porta parallela LPT disponibile

Tutto qui. Ovviamente è necessario possedere un registratore a cassette della Commodore o uno 100% compatibile. Inoltre bisogna costruire una semplice interfaccia per connettere tale periferica alla porta parallela (vedi sezione più in basso).

In questa pagina sono disponibili i sorgenti, l’eseguibile, modalita’ d’uso, un po’ di documentazione varia, lo schema dell’interfaccia da costruire e le specifiche riguardo al formato dei file TAP.

Sorgenti

TapeRipper e’ scritto in C ed e’ composto da un unico file sorgente. L’ho scritto e compilato sotto DJGPP senza alcun problema. Per eseguire il programma bisogna assicurarsi di essere in ambiente DOS in modalita’ reale dato che sotto windows (9x/NT/ME/XP) non si possono garantire misurazioni di tempo troppo accurate (causa i cambi di contesto improvvisi tra processi). Per l’esecuzione e’ necessario inoltre un gestore DPMI come CWSDPMI.EXE localizzato nella stessa directory del programma e avere il loader della memoria alta attivato (tale himem.sys).

Codice sorgente: tape_ripper

File binari

Il programma già compilato e pronto per essere eseguito: ripper.exe (115kB)
ed il server DPMI: cwsdpmi.zip (53kB)

Documentazione

Un po’ di roba che mi è tornata utile per realizzare il programma:

Temporizzazione del PC sotto DOS

L’archivio tratta la temporizzazione e varie funzioni correlate sui computer della famiglia IBM compatibili sotto DOS; funzioni DOS e BIOS, BIOS tick count, interruzioni hardware, timer tick interrupts, port B, il timer 8253/8254, velocizzare il conteggio del timer, dynamic tick periods, simulazione dell’interruzione del vertical retrace, buffering doppio e triplo, timestamping assoluto, l’RTC (Real Time Clock), altri metodi di misurazione del tempo, lettura della porta joystick, generazione PWM del suono tramite speaker interno. Sono presenti anche programmi di esempio precompilati.
pctim003
Autore: Kris Heidenstrom kheidens@actrix.gen.nz

Il timer interrupt
Guida facile e veloce alla riprogrammazione del timer interrupt (detto anche 8253); come settare il registro di controllo, la lettura dai canali e le modalita” di funzionamento. Con esempi in C++.
timerinterrupt

C64 Programming Reference Manual
Un malloppone ASCII di quasi 1MB contenente tutto quello che c’e’ da sapere sul Commodore64: programmazione BASIC e linguaggio macchina, memoria, CPU, I/O, etc…
c64manual

Teoria e funzionamento delle bande magnetiche
Riguarda le carte magnetiche ma il concetto e’ applicabile anche ai normali nastri in cassetta.
p37-06

Interfaccia

L’interfaccia da me realizzata permette di collegare il registratore del C64 al PC. E’ abbastanza semplice da realizzare.

lpt64

In alto e’ la porta parallela femmina del PC ed in basso un connettore maschio per la spina del registratore a cassette. Il connettore lo si puo’ costruire sagomando con un seghetto una vecchia scheda elettronica di quelle a inserimento stile “cartuccia del Nintendo” molto frequenti nei televisori. Per il resto basta un saldatore, stagno, qualche filo elettrico ed una sorgente da 5Volt piu’ stabile possibile, ad esempio quella che viene fornita dall’alimentatore del PC stesso, oppure prelevata dalla porta joystick (pin1 +5volt e pin4 massa). Volendo si puo’ costruire direttamente l’alimentatore a 5Volt: ecco lo schema:

5volt

  • B1 – ponte diodi rettificatore
  • C1,C2 – condensatori elettrolitici da 470uF
  • IC1 – regolatore di tensione 7805

Per quanti vogliano cimentarsi con la modifica diretta dell’hardware del registratore ne riporto lo schema elettrico

c2n

Formato del file .TAP

Il formato .TAP, riconosciuto praticamente da qualsiasi emulatore per Commodore64 che si rispetti, e’ nato con l’intento di descrivere bit a bit i dati (programmi e/o giochi) memorizzati su nastro. Essendo una semplice rappresentazione dei dati seriali provenienti dal nastro e’ in grado di memorizzare qualsiasi codifica dei dati sia stata utilizzata. Le immagini .TAP sono solitamente di dimensioni molto maggiori (in rapporto all’incirca di 8:1) rispetto a quella dei dati che effettivamente vanno a caricarsi in memoria, in quanto ogni singolo byte del file .TAP rappresenta la durata (misurata in cicli CPU) di una pulsazione rilevata dal registratore e corrispondente ad un singolo bit del programma utile. In altri schemi di codifica, invece, due pulsazioni codificano un bit; tali dettagli di codifica, comunque, non sono presi in cosiderazione dal formato TAP in nessun modo in quanto ci si limita unicamente a registrare gli istanti di generazione delle pulsazioni da parte dell’hardware del registratore.

Questo e’ un esempio di header per un generico file .TAP:


HEX 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ASCII
----------------------------------------------------- ----------------
0000: 43 36 34 2D 54 41 50 45 2D 52 41 57 00 00 00 00 C64-TAPE-RAWúúúú
0010: 51 21 08 00 2F 0F 0D 31 64 1D 26 0D 07 21 0A 12 Q!úú/úú1dú&úú!úú
0020: 4A 2F 2C 34 07 18 0D 31 07 04 23 04 0D 42 0D 1E J/,4úúú1úú#úúBúú
0030: 34 04 42 0D 20 15 5E 04 0D 18 61 0D 26 29 34 0D 4úBúúú^úúúaú&)4ú
0040: 23 0D 07 0A 3F 55 04 0A 13 3F 07 0D 12 2B 18 0A #úúú?Uúúú?úúú+úú

dove:

  • $0000-000B: rappresentano la scritta in ASCII “C64-TAPE-RAW”
  • $000C: versione del file TAP
  • $000D-000F: non usati
  • $0010-0013: dimensione dell’intero file (in big-endian) meno l”header
  • $0014-EOF: dati veri e propri

Nella versione 0 del file (quindi con il byte $000C settato a 0x00) ogni singolo byte descrive la durata di una pulsazione. Un byte pari a 0x00 viene interpretato come una pulsazione la cui durata andrebbe a generare un valore superiore a 0xFF. Nella versione 1 del file (0x01 alla locazione $000C) tali pulsazioni che non possono essere codificate con un unico byte sono memorizzate su quattro bytes: il primo posto a 0x00 e i successivi tre che indicano l”effettiva durata in cicli della pulsazione.
La formula che si utilizza e’

P = (8 * BYTE) / (CICLI_CPU)

dove P e’ la durata in secondi della pulsazione, BYTE e’ il byte codificato nel file TAP e CICLI_CPU e’ il clock del processore in Hz (nel Commodore64 versione PAL vale 985248 Hz). Ad esempio, un valore di 0x2F (47 in decimale) nel file TAP rappresenta una pulsazione di durata pari a (47 * 8) / 985248 = 0.00038975 secondi.

Bug noti e migliorie

  • TapeRipper ha un buffer di 4Mbytes fisso; si puo’ aumentare solo modificando il sorgente
  • Il file di uscita e’ fisso con nome “out.tap”. Se un altro file con lo stesso nome e’ gia’ presente prima dell’avvio del programma, questo verra’ sovrascritto
  • Durante la lettura non viene mostrato nulla sullo stato di avanzamento della cassetta
  • Se l’interfaccia e’ scollegata il programma attende per la pressione del tasto STOP sul registratore!
  • Il formato TAP versione 1.0 non e’ implementato

Ecco qua l’hardware completato:

dscn1033