Top

Usare joystick PS2 sul PC e sulla PS3 con Arduino.

VERSIONE IN INGLESE QUI | ENGLISH VERSION HERE

Prodotto interamente in Italia ma utilizzato in tutto il mondo, Arduino è uno delle più famosi schede con microcontrollori esistenti, ci permette di eseguire le operazioni più svariate ed è molto utilizzato nello sviluppo e nella prototipazione di diversi dispositivi.

Uno degli utilizzi che si può fare di Arduino è quello di convertire il joystick PS2 in joystick per PC o PS3.

PREMESSA: la guida è da considerarsi al solo scopo illustrativo. Non ci assumiamo nessuna responsabilità per eventuali danni provocati.

Iniziamo! Per prima cosa procuriamoci il necessario:

  • Arduino Uno (vanno bene anche Leonardo e Mega): se non l’avete ancora comprato, e volete farlo solo per poter usare il vostro joystick Play Station 2, vi sconsiglio di acquistarlo visto che vi costa meno un convertitore PS2-PC (pochi euro su eBay).
  • Arduino IDE.
  • Libreria/firmware UnoJoy: potete scaricarla gratuitamente da Google Code, scegliendo il vostro sistema operativo e il modello di Arduino.
  • Libreria PS2X: creata da Bill Porter, la potete scaricare dal suo sito (scendendo un po’ trovate Download PS2X).
  • Breadboard (facoltativa ma altamente raccomandata).
  • Una resistenza da 10kOhm.
  • E naturalmente un Joystick PS2 che non vi serve più (è consigliabile tagliare il connettore, anche se si può evitare).

Un piccolo avvertimento prima di iniziare: la vibrazione non funzionerà, o meglio si potrebbe far funzionare attraverso l’uso di transistor e di una modifica del codice ma, sinceramente, il gioco non vale la candela.

PRIMO PASSO: effettuiamo i collegamenti

Per prima cosa è bene sapere che il controller della Play Station 2 ha 9 fili (o 8 per i controller più recenti) che possono differire di colore in base all’anno del joystick.

I colori più comuni sono i seguenti, di cui potete trovare un’immagine su Curious Inventer:

Bianco: funzione sconosciuta e, guarda caso, è proprio il cavo mancante nei controller a 8 fili.

Grigio: vibrazione (che non useremo).

Verde: “acknowledge”, serve nella comunicazione tra controller e PS2 ma a noi non servirà.

NERO: è la comune messa a terra.

ROSSO: è il positivo (3.3V).

MARRONE: è il cavo dati utilizzato dal joystick per inviare segnali alla PlayStation.

ARANCIONE: è il cavo command“, viene utilizzato dalla PlayStation per inviare segnali al joystick.

GIALLO: è l'”attention” (non ho idea di quello che è il suo funzionamento).

BLU: è il clock, serve per stabilire la velocità di trasmissione dati.

Bene, passiamo all'”assemblaggio“, dotiamoci di Breadboard e della resistenza da 10kOhm e via.

Questo è il collegamento da effettuare, come vedete è facile da realizzare.

Collegamenti Arduino

 Per semplificarvi ancora di più, ho creato questo schema (con il mitico Fritzing, che mi ha fatto l’arancione verde-acqua):

collegamenti

Allora iniziamo.

Prendete un filo del joystick, spellatelo e avvolgete il materiale conduttore su uno dei due puntali di un jumper (lasciandone un altro libero). Inserite il jumper (diventato tutt’uno con il filo) nella breadboard. Ripetete quest’operazione per tutti i fili utilizzati (sono 6), lasciando tra ogni filo 2 buchini di breadboard liberi (come ho fatto io), per evitare spiacevoli cortocircuiti. Collegate i fili seguendo il mio stesso ordine (nero, rosso, marrone, arancione, giallo e blu) per evitare qualche spiacevole mal collegamento.

Prendete il puntale, che prima avete lasciato libero, del jumper del filo nero e collegatelo ad uno dei pin GND su arduino (ce ne sono 3, vanno tutti bene).

Dopodiché prendete la resistenza da 10kOhm e posizionatela, nella breadboard, come rappresentato nelle immagini. Collegate il filo rosso ad uno dei lati della resistenza e, con un altro jumper, collegateci la 3.3v (di Arduino, s’intende) in serie (se non avete capito guardate sempre lo schema). Dall’altro capo della resistenza collegate il filo marrone (nella mia foto corrisponde al jumper verde) e in serie collegatelo al PIN 11 (guardate sempre lo schema).

Il cavo arancione collegatelo al PIN 9, quello giallo al PIN 8 e il blu al PIN 10.

Ecco fatto, con i collegamenti abbiamo finito!

[banner]

SECONDO PASSO: Programmiamo

Bene, siamo arrivati ad un punto cruciale: la programmazione di Arduino!

Iniziamo con l’aprire Arduino IDE e ad importare la libreria PS2X (che abbiamo precedentemente scaricato e scompattato). Per farlo clicchiamo su Sketch >> Importa libreria >> Add Library, comparirà una finestra dove dovremo selezionare la cartella PS2X_lib (che si trova all’interno della cartella madsci…).

Bene, ora, minimizzando l’IDE, spostiamoci dentro la cartella di UnoJoy (o LeoJoy o MegaJoy). Noteremo la presenza di una cartella chiamata “UnoJoyArduinoSample” (o equivalenti), che contiene al suo interno un file .ino (il formato che viene aperto dall’iDE) e un file .h, copiamola e incolliamola (ne creiamo così un duplicato) e rinominiamo il duplicato nel nome che più ci piace, io userò come nome playstation.

Apriamo la cartella playstation appena creata e rinominiamo il file .ino in playstation.ino. Dopodiché, con un doppio click, apriamo il file con Arduino IDE. Cancelliamo tutto il codice presente (CTRL+A e poi CANC) e scriviamo il seguente (alternativamente potete scaricare il file già pronto da qui):

[c]

#include "UnoJoy.h"
#include <PS2X_lib.h>

#define PS2_DAT 11 //14
#define PS2_CMD 9 //15
#define PS2_SEL 8 //16
#define PS2_CLK 10 //17

//#define pressures true
#define pressures false
//#define rumble true
#define rumble false

PS2X ps2x;

int error = 0;
byte type = 0;
byte vibrate = 0;

void setup(){
setupPins();
setupUnoJoy();
}

void loop(){
// Always be getting fresh data
dataForController_t controllerData = getControllerData();
setControllerData(controllerData);
error = ps2x.config_gamepad(PS2_CLK, PS2_CMD, PS2_SEL, PS2_DAT, pressures, rumble);
}

void setupPins(void){
// Set all the digital pins as inputs
// with the pull-up enabled, except for the
// two serial line pins
for (int i = 2; i <= 12; i++){
pinMode(i, INPUT);
digitalWrite(i, HIGH);
}
pinMode(A4, INPUT);
digitalWrite(A4, HIGH);
pinMode(A5, INPUT);
digitalWrite(A5, HIGH);
}

dataForController_t getControllerData(void){

// Set up a place for our controller data
// Use the getBlankDataForController() function, since
// just declaring a fresh dataForController_t tends
// to get you one filled with junk from other, random
// values that were in those memory locations before
dataForController_t controllerData = getBlankDataForController();
// Since our buttons are all held high and
// pulled low when pressed, we use the "!"
// operator to invert the readings from the pins
ps2x.read_gamepad(false, vibrate);
controllerData.triangleOn = ps2x.Button(PSB_TRIANGLE);
controllerData.circleOn = ps2x.Button(PSB_CIRCLE);
controllerData.squareOn = ps2x.Button(PSB_SQUARE);
controllerData.crossOn = ps2x.Button(PSB_CROSS);
controllerData.dpadUpOn = ps2x.Button(PSB_PAD_UP);
controllerData.dpadDownOn = ps2x.Button(PSB_PAD_DOWN);
controllerData.dpadLeftOn = ps2x.Button(PSB_PAD_LEFT);
controllerData.dpadRightOn = ps2x.Button(PSB_PAD_RIGHT);
controllerData.l1On = ps2x.Button(PSB_L1);
controllerData.r1On = ps2x.Button(PSB_R1);
controllerData.selectOn = ps2x.Button(PSB_SELECT);
controllerData.startOn = ps2x.Button(PSB_START);
controllerData.l2On = ps2x.Button(PSB_L2);
controllerData.l3On = ps2x.Button(PSB_L3);
controllerData.r2On = ps2x.Button(PSB_R2);
controllerData.r3On = ps2x.Button(PSB_R3);

// Set the analog sticks
// Since analogRead(pin) returns a 10 bit value,
// we need to perform a bit shift operation to
// lose the 2 least significant bits and get an
// 8 bit number that we can use
controllerData.leftStickX = ps2x.Analog(PSS_LX), DEC;
controllerData.leftStickY = ps2x.Analog(PSS_LY), DEC;
controllerData.rightStickX = ps2x.Analog(PSS_RX), DEC;
controllerData.rightStickY = ps2x.Analog(PSS_RY), DEC;
// And return the data!
return controllerData;
}

[/c]

Dopo aver incollato il codice qui sopra o aver scaricato il file (e posizionato nella cartella playstation dentro UnoJoy e aperto con l’IDE), verifichiamolo e carichiamolo sull’Arduino (che abbiamo collegato via USB al PC).

Se vi da problemi durante la compilazione, per una libreria mancante, provate a fare Sketch >> Importa libreria >> PS2X_lib. Se i problemi persistono cercate di capire dov’è il problema, controllate di aver fatto tutto bene e inviate un commento: sarò lieto di aiutarvi!

Bene, dopo aver caricato il file, salviamolo e chiudiamo l’IDE. Andiamo nella cartella di UnoJoy e apriamo la cartella “UnoJoyProcessingVisualizer“. All’interno di questa troviamo un file eseguibile che, su Windows, si chiama UnoJoyProcessingVisualizer.exe.

Eseguiamolo (doppio click), si aprirà una finestra con un joystick, selezioniamo la porta COM giusta e poi proviamo a cliccare qualche tasto sul joystick: se funziona siamo pronti per il prossimo step, altrimenti ricontrollate il tutto (soprattutto i collegamenti dei fili!) e commentate se non riuscite a risolvere.

TERZO PASSO: trasformiamo Arduino in un joystick

E siamo giunti al terzo passo, il più delicato di tutti.

Quello che andremo a fare sarà modificare il chip USBtoSerial di Arduino, l’Atmega16U2 o l’Atmega8U2 (quello vicino l’USB, non quello estraibile).

Ricordo che non mi assumo nessuna responsabilità per eventuali danni provocati e vorrei precisare che la seguente è un’operazione rischiosa che potrebbe compromettere il vostro Arduino (portandolo a non funzionare).

La modalità DFU di Arduino richiede, in alcuni casi, una modifica al chip con l’aggiunta di una resistenza , vi consiglio di conseguenza di informarvi sul vostro modello di Arduino riguardo la modalità DFU prima di procedere.

Nel mio caso, Arduino UNO R3, non è stata necessaria nessuna modifica (ma non posso assicurare lo stesso per altri Arduino UNO R3).

Come prima cosa installate i driver per il vostro sistema operativo (li trovate dentro la cartella di UnoJoy, nella sottocartella Drivers), dopodiché, se siete su Windows, dovete installare anche Atmel’s FLIP.

Fatte le installazione, è arrivata l’ora di mettere il nostro Arduino in modalità DFU, per farlo dobbiamo cortocircuitare i 2 pin maschi (dei 6 totali) più vicini all’USB, potete effettuare il cortocircuito usando il puntale di un jumper.

Modalità DFU

Subito dopo aver fatto il contatto l’Arduino non verrà più rilevato come tale ma, bensì, come Atmega16U2 (o Atmega8U2). Se non viene riconosciuto controllate di aver correttamente installato i driver.

In modalità DFU, apriamo la cartella di UnoJoy e clicchiamo su TurnIntoAJoystick. Dopo pochi secondi (e tante scritte) comparirà un “Press any key to exit“, premete un tasto e si chiuderà la finestra. A questo punto staccate e riattaccate l’USB et voilà: il vostro joystick PS2 è compatibile sia con il PC che con la PS3!

Ecco qualche prova del funzionamento:

unojoy

Naturalmente funzionano anche tutti gli altri tasti e, come potete vedere dall’immagine seguente, gli assi vengono rilevati perfettamente anche con i valori intermedi.


unojoy2

RITORNO AD ARDUINO

Certamente non possiamo impegnare il nostro Arduino sempre e costantemente come joystick. Se vogliamo riaverlo indietro non basterà altro che rimetterlo in DFU mode e, sempre nella cartella di UnoJoy, eseguire TurnIntoAnArduino. Aspettiamo pochi secondi, clicchiamo il tasto per chiudere la finestra (aspettate sempre che compaia, senza errori, la scritta “Press any key to exit“) e staccate e riattaccate l’USB ed ecco di nuovo indietro il nostro amato Arduino.

Se avete problemi di ogni genere non esitate a commentare, cercheremo di risolverli 🙂

Powered by WordPress. Designed by WooThemes