Conectar modulo RF XBOX 360 FAT a PC
En la siguiente entrada vamos a realizar la conexión electrónica del modulo RF que incorporan las consolas xbox 360 fat para conectar sus respectivos mandos de juego.
Funcionamiento del modulo: el modulo que estas viendo en pantalla es el componente que utilizan las consolas de tipo xbox 360 fat para conectar de forma inalambrica los controles a dicha consolas.
Muchas veces las consolas son enviadas al deposito del reciclaje por su alta taza de fallas provocada por el chip APU que se daña a causa de falsos contactos en la soldadura, sin embargo es posible rescatar estos módulos y utilizarlos para interconectar los controles de 360 a una pc con Windows, lo mas interesante es que el modulo permite la conexión de hasta 4 mandos a través de una sola conexión usb.
Bien es cierto que en el mercado existe un producto que cumple con esta función, son llamados receptor usb de xbox 360 para pc.
Funcionamiento
El modulo que integra xbox 360 fat y puntualizo (FAT) por que esta es la única versión del modulo que nos servirá para el código que presentaremos a continuación. básicamente es un chip que cuenta con conexiones de tipo USB que fácilmente podemos cablear e interconectar a nuestra PC, en la siguiente imagen te compartimos su estructura de conexión.
Como podrás ver en el esquema anterior al visualizar el modulo rf desde el frente, podemos ubicar la conexión de B+/D-/D+/GND mismas que son utilizadas para conectar a un cable usb de tipo macho, mas abajo podrás ver un arreglo con una placa Arduino que utiliza 3 cables extras de los cuales 2 sirven para comunicarse con el chip de control RF que (enviar comandos) Signal Clock y Signal Data, el tercero básicamente es la señal a tierra (gnd) que cierra cuando pulsamos el swich del centro para sincronizar los controles.
Un punto importante a tomar en consideración es que la placa RF se alimenta con 3.3 y no 5V, como en este caso el usb funciona, es por ello que dicha tensión se limita utilizando 2 diodos 1n4007 en serie hacia la alimentacion de la placa RF y los 5v van directo al puerto de alimentacion del Arduino.
Vista desde la parte trasera al retirar el conector.
En cuanto a las señales de Data y Clock estas se conectan respectivamente a la placa Arduino en DATA-Digital 3 y Clock en Digital 4 de la placa Arduino sumándole en paralelo una resistencia de 10Kh a tierra desde cada señal a tierra (GND) con el fin de estabilizar la señal.
Para finalizar en el arreglo conectamos la salida a tierra del Power Swich a Digital 2 de Arduino que nos permitirá interactuar con nuestra placa arduino al enviar la señal de sincroniza.
Una vez tenemos todas las conexiones listas lo que procede es programar nuestra placa Arduino, para este proyecto te recomendamos un modulo Arduino pequeño, como lo es el arduino mini, luego desde nuestra pc ingresando el siguiente código:
/* Arduino code to communicate with xbox 360 RF module.
Original work by (yaywoop)
Additional ideas from Alexander Martinez
Modified by dilandou (www.dilandou.com, www.diru.org/wordpress)
Controller turn off added by Martin Ballantyne using research from http://tkkrlab.nl/wiki/XBOX_360_RF_Module
First sends LED initialisation code followed by LED startup animation code, then sleeps until a button press for sync command.
If the sync button is held down and released after 1000ms the connected controllers will be turned off. Otherwise the sync command will initiate.
RF module must be powered with 3.3V, two diodes in series with USB 5v will do. Connect the USB wires to a host computer, and the data and serial wires to Arduino.
of course, make sure to have a common ground */
#include
#define sync_pin 2 //power button repurposed for sync button (pin 5 on the module)
#define data_pin 3 //data line (pin 6 on the module)
#define clock_pin 4 //clock line (pin 7 on module)
int led_cmd[10] = {0,0,1,0,0,0,0,1,0,0}; //Activates/initialises the LEDs, leaving the center LED lit.
int led_timer_red_1[10] = {0,0,1,0,1,1,1,0,0,0}; //Set quadrant 1 to red
int led_timer_red_2[10] = {0,0,1,0,1,1,1,1,0,0}; //Set quadrant 1 and 2 to red
int led_timer_red_3[10] = {0,0,1,0,1,1,1,1,0,1}; //Set quadrant 1, 2 and 4 to red
int led_timer_red_4[10] = {0,0,1,0,1,1,1,1,1,1}; //Set quadrant 1, 2, 3 and 4 to red
int led_red_off[10] = {0,0,1,0,1,1,0,0,0,0}; //Set quadrant 1, 2, 3 and 4 to off
int anim_cmd[10] = {0,0,1,0,0,0,0,1,0,1}; //Makes the startup animation on the ring of light.
int sync_cmd[10] = {0,0,0,0,0,0,0,1,0,0}; //Initiates the sync process.
int turn_off_cmd[10] = {0,0,0,0,0,0,1,0,0,1}; //Turns off the connected controllers.
volatile boolean sync_pressed = 0;
int sync_hold_time = 0;
boolean turn_off_controllers = false;
void sendData(int command[])
{
pinMode(data_pin, OUTPUT);
digitalWrite(data_pin, LOW); //start sending data.
int previous_clock = 1;
for(int i = 0; i < 10; i++)
{
while (previous_clock == digitalRead(clock_pin)){} //detects change in clock
previous_clock = digitalRead(clock_pin);
// should be after downward edge of clock, so send bit of data now
digitalWrite(data_pin, command[i]);
while (previous_clock == digitalRead(clock_pin)){} //detects upward edge of clock
previous_clock = digitalRead(clock_pin);
}
digitalWrite(data_pin, HIGH);
pinMode(data_pin, INPUT);
delay(50);
}
void setHeldLEDs(int held_time)
{
if(held_time >= 1000)
{
sendData(led_timer_red_4);
}
else if(held_time >= 750)
{
sendData(led_timer_red_3);
}
else if(held_time >= 500)
{
sendData(led_timer_red_2);
}
else if(held_time >= 250)
{
sendData(led_timer_red_1);
}
else
{
sendData(led_red_off);
}
}
void initLEDs()
{
sendData(led_cmd);
sendData(anim_cmd);
}
void wakeUp()
{
sync_pressed = 1;
}
void sleepNow()
{
set_sleep_mode(SLEEP_MODE_PWR_DOWN); // set sleep mode
sleep_enable(); //enable sleep bit
attachInterrupt(0, wakeUp, LOW);
sleep_mode();
sleep_disable(); //disable sleep bit
detachInterrupt(0); // disables interrupt 0 on pin 2
}
void setup()
{
Serial.begin(9600);
pinMode(sync_pin, INPUT);
digitalWrite(sync_pin,HIGH);
pinMode(data_pin, INPUT);
pinMode(clock_pin, INPUT);
delay(2000);
initLEDs();
}
void loop()
{
// Only sleep if the sync button is not held down
if(!sync_pressed)
{
sleepNow();
}
delay(200);
if(sync_pressed)
{
Serial.print("Sync held time (ms): ");
Serial.println(sync_hold_time, DEC);
setHeldLEDs(sync_hold_time);
// Count 1000ms, if elapsed the user wants to turn off their controllers
if(sync_hold_time >= 1000)
{
turn_off_controllers = true;
sync_hold_time = 1000;
}
// Initiate the user's action when they release the sync button
if (digitalRead(sync_pin))
{
setHeldLEDs(0);
if(turn_off_controllers)
{
Serial.println("Turning off controllers.");
sendData(turn_off_cmd);
turn_off_controllers = false;
}
else
{
Serial.println("Syncing controllers.");
sendData(sync_cmd);
}
// Action complete, reset hold time and button state
sync_hold_time = 0;
sync_pressed = false;
}
else
{
sync_hold_time += 200;
}
}
}
una ves copiado, pegado y cargado el código en Arduino, desconectamos el Arduino y procedemos a conectar el cable usb de nuestro modulo RF. La computadora realizara el reconocimiento y solo bastara instalar el driver de XBOX 360 para que nuestro modulo funcione.
Drivers de XBOX-360
- Damos clic derecho en dispositivo desconocido.
Luego - Elegir de una lista.
- Por ultimo Receptor inalámbrico de XBOX 360.
- Damos SI en la advertencia.
Y listo, el controlador esta conectado, en espera para sincronizar control.
Como paso final hacemos la sincronización de los controles xbox 360 a utilizar como si de una consola se tratase.
En este caso solo debes montar el cable usb soldando los puntos con sus correspondientes colores D+/D-/GND y bajar la tensión igual con 2 diodos en serie 1n4007 de 5v a 3.3v.
Comentarios