Tutorial: Xbox 360 wireless controller to PC (via RF module and Attiny 45/85)

For some time I've been working on a self made way to connect my Xbox 360 controller to my pc. I could have gone on eBay or other similar places and bought a receiver for the controller but then what kind of a geek would have I been:)). So I've gone on the not so difficult road of modifying a xbox 360 phat RF module.

Well I've started off buying a RF module off a dead Xbox 360 since I didn't have any laying around the house, prior to that the guy that I got the RF module from was kind enough to pair one of my controllers to it and let me test out the module so we could be sure everything was working correctly.

VERY IMPORTANT. If you are planning to get an RF module but not get the Attiny chip remember once you UNPAIR the controller from the RF module it is impossible to pair it back up without a console atached to the RF module.

Well to get all things out of the way and slim it down a bit I took the connector off the module and therefor made it a bit smaller the way to connect it is very simple for testing purposes, you have the schematic below (ignore the Arduino).

The module is running on 3.3V so you'll have to take the 5V provided by the USB plug and take it a bit down so that you don't fry the board, 2x 1N4001 diodes in series should be enough to get the board working and test it out.
Now that we have that sorted out we can take care of the software side on the PC, now if you plug the module in a USB port you will soon find out that it doesn't work, don't be alarmed you just have to point out the PC to the correct drivers;) since the module doesn't have a hardware id and is not recognized.


There are 2 easy methods of doing this and both start with installing the xbox 360 wireless controller drivers for windows found here.

Method nr 1:
After this you can do it either by going into device manager (right click on My Computer => Properties => Device Manager) and there you will see your RF Module with a yellow exclamation mark on it from there you can click Update Drivers => Browse my computer for driver software => Let me pick from a list of device drivers on my computer and now you have to browse for Xbox 360 Wireless Controller.

Method nr 2:
Prior to this method you need to have the RF Module unplugged from the PC, go to the install folder (Microsoft Xbox 360 Acessories) in your program files and find Xusb21.inf this is the driver file for the software you will be modifying it so it will recognize your hardware.
Open it with a text editor or a program like Notepad++ (recomended) and find these headers [MSFT.NTx86.6.0], [MSFT.NTamd64.6.0], [MSFT.NTx86], and [MSFT.NTamd64].

you are going to replace the 5 lines of code under each of them, the original code looks like this:
%XUSB21.DeviceName.Wired%=CC_Install, USB\Vid_045E&Pid_028E
%XUSB21.DeviceName%=CC_Install, USB\Vid_045E&Pid_0719
%XUSB21.DeviceName.Wired%=CC_Install, USB\MS_COMP_XUSB10
%XUSB21.DeviceName%=CC_Install, USB\MS_COMP_XUSB20
%XUSB21.DeviceName.Jump%=CC_Install, USB\Vid_045E&Pid_028F

what you will put in its place looks like this
%XUSB21.DeviceName.Wired%=CC_Install, USB\Vid_045E&Pid_0291
%XUSB21.DeviceName%=CC_Install, USB\Vid_045E&Pid_0291
%XUSB21.DeviceName.Wired%=CC_Install, USB\UNKNOWN
%XUSB21.DeviceName%=CC_Install, USB\UNKNOWN

now save it (make sure you save as a .inf file or it wont work).
After that plug in your RF module and is should find drivers all on it's own;).

Also if you have a arduino laying around and you are not using it for anything you can give it a try and test it out to see if it's working;), all you have to do is hook it up like in the schematic above and load the following code to your Arduino.

CODE:

#include <avr/sleep.h>
#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 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.
volatile boolean sync_enable = 0;
void sendData(int cmd_do[]) {
pinMode(data_pin, OUTPUT);
digitalWrite(data_pin, LOW); //start sending data.
int prev = 1;
for(int i = 0; i < 10; i++){
while (prev == digitalRead(clock_pin)){} //detects change in clock
prev = digitalRead(clock_pin);
// should be after downward edge of clock, so send bit of data now
digitalWrite(data_pin, cmd_do[i]);
while (prev == digitalRead(clock_pin)){} //detects upward edge of clock
prev = digitalRead(clock_pin);
}
digitalWrite(data_pin, HIGH);
pinMode(data_pin, INPUT);
}
void initLEDs(){
sendData(led_cmd);
delay(50);
sendData(anim_cmd);
delay(50);
}
void wakeUp(){
sync_enable = 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();
// sendData(sync_cmd);
}
void loop(){
Serial.println("Sleeping.");
sleepNow();
delay(200);
if(sync_enable==1) {
Serial.println("Syncing.");
sendData(sync_cmd);
sync_enable = 0;
}
}

Lets say that's a step forward now and you can sync any controller you want with the board as long as you have the Arduino connected. I wanted to get the RF Module to have it's own Atmel chip that would handle those functions including syncing and a 3.3V voltage regulator to get rid of those ugly looking diodes, since it's only a 1.7V drop and not a lot of current going trough, it wouldn't required a heatsink or some way of dissipating heat so i went with this method.

So my choice of parts for this build was a Atmel Attiny 85 20su (you can also go for the Attiny 45) meaning it was surface mounted and a voltage regulator LM1117-33 also surface mounted. Since my build was meant to be as compact as possbile and as sturdy as possible I printed my own circuit board, designed in Eagle (I will be covering making your own circuit boards in another tutorial tho there are a few around on the internet and it's a pretty straight forward).
I'll be also posting the files for the circuit and the modified code for the chip since it's got a different pinout as the Atmega328. Pick your pins correctly otherwise it won't work as planned. Only some pins of the Attiny are able to wake the chip out of sleep so if you don't pick your pins correctly the chip will not wake up from sleep and won't do the syncing procedure.

The only modification to the code is that the first few lines have to be replaced with these ones:

#include <avr/sleep.h>
#define sync_pin 2 //power button repurposed for sync button (pin 5 on the module)
#define data_pin 1 //data line (pin 6 on the module)
#define clock_pin 0 //clock line (pin 7 on module)

I've designed the board in such way that it can be programmed on the spot, you will just have to solder some wires to the program pins.

The final product. It ain't pretty it's a bit bigger and it's not almost plug and play as is the original one but it gets the job done and it has a lot of pretty lights:). All you will have to do after it is programmed is hook up the wires, ground wire from the USB connector, 5V to power the Attiny and the voltage regulator and on the output side first you will have to solder the 3.3V coming from the voltage regulator to the RF Module so the electronics on the board are powered and after that the 3 wires coming from the Attiny going RF Module. That's all.

Well now to add to all of this I haven't been able to play a lot with the functionability tho it is possible to add other functions to the board with the help of this:

//GREEN EDGE LEDs
0010100001 = "upper left"
0010100010 = "upper right"
0010100100 = "lower left"
0010101000 = "lower right"

//RED EDGE LEDs
0010110001 = "upper left"
0010110010 = "upper right"
0010110100 = "lower left"
0010111000 = "lower right"

//RED EDGE LEDs blink
0011010001 = "all"
0011010010 = "upper left"
0011010011 = "upper right"
0011010101 = "lower left"
0011010100 = "lower right"

//CONTROLLER
0000001000 = "Syncing"
0000001001 = "shutdown controller"

//MISC
0010000101 = "Start Animation"
0010000100 = "init Leds - leave middle LED on"

These are the binary codes that drive the board and are sent by the Attiny with a bit of change in the code it's able to make the board do other things also.
Have fun;) and let me know what you've tried and what has worked or didn't work for you.

Finally got around to uploading the files have fun and enjoy;)
Attiny85 Xbox 360 controller sketch
Xbox 360 controller sketch