Search

Xbox 360 Rf Module Controlled With An Arduino

About the project

Using an Arduino UNO R3 board you can Sync, Turn off, and use any Xbox 360 Wireless controller Using 3 types of RF Modules while even using Microsoft's own Xbox 360 Wireless Controller Receiver Driver. If desired you can even 3D print your own case for the device to make it look a better than just having the plain boards.

Project info

Difficulty: Expert

Platforms: ArduinoMicrosoftWindows

Estimated time: 1 day

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

Arduino Uno - R3 Arduino Uno - R3 This is the recommended board to use however some people have had success with an Arduino Leonardo. x 1
Xbox 360 RF Module Xbox 360 RF Module This Absolutely has to be the REV F RF01, RF02 board or the REV B board. You can easily find these all over eBay for about $6 a piece x 1
10k OHM resistor 10k OHM resistor These are needed for the CLK wire and the DATA wires. x 2
300MW 3.3V 300MW 3.3V Any will do so long as they step the voltage down from 5v to 3.3v this also very important as the RF module wont power on the serial side until its stepped down. x 2
Hook-up Wire - Black (22 AWG) Hook-up Wire - Black (22 AWG) Any wires will do but do keep in mind that you should pick one that is flexable and that you solder to it with little trouble x 1

Software apps and online services

Arduino IDE Arduino IDE This is used to Edit and to Upload the code to your Arduino
Windows 7,8,10 Windows 7,8,10 This project will work with any version of windows that supports the xbox 360 wireless receiver driver.

Hand tools and fabrication machines

Soldering Iron Soldering Iron This will have many uses with this project but you may need a high temp iron because the RF Module and the Xbox 360 use lead free high temp solder. x 1
(OPTIONAL) Hot Air Station (OPTIONAL) Hot Air Station This is Optional but I used to desolder the socket the RF module sits in off an xbox 360 motherboard to make testing a lot easier. x 1
Multi-Meter Multi-Meter This is so you can double check your voltages and to make sure those voltages are in the correct range. x 1
(OPTIONAL) Xbox 360 tool kit (OPTIONAL) Xbox 360 tool kit This will be handy for taking apart any xbox 360 that you may have for harvesting the RF module from it. However id suggest just getting one off eBay x 1
Solder (Low temp if possible) Solder (Low temp if possible) I prefer lead based so it has a much higher durability and its a lot easier to fix mistakes with this project because high heat on the RF module may damage it. x 1
Solder Wick or a Solder sucker Solder Wick or a Solder sucker I used the solder sucker for this since I myself had a hard time getting the lead free solder to flow to solder wick x 1

Story

NOTE: I will provide links at the bottom of the guide that will give you the same resources I mention through out the guide. That way you won't have to hunt them yourself. Another note this is mainly for PHAT XBOX 360s, The USB part does work for slims but not the Arduino part. The consoles you can get the RF Modules from are the Xenon, Zepher, Falcon, and Jaspers. 

I am a huge Xbox 360 enthusiast, I own 4 dev kits (witch games are tested and stressed on) and 1 Halo 3 RGH, and a few other normal retail units. I used to fix them for fun in my free time but I have always had a fascination for the console.

I like to tinker with the hardware here and there but I wanted to try an odd project people around 2012 used to try out themselves. The Xbox 360 has some very unique designs to its hardware and one of the them is its Controller RF Module. 

I need to explain a bit about how these work so you get an idea of what the Arduino is actually doing in the circuit. The Module has a bit of retro tech and new tech all in one when its busy working away. One side is the RF module for the controllers and the other is the serial controller on it that receives commands/sends controller data to the Xbox 360.

Here is a couple photos of what to expect these to look like when you get one. These may differ slightly depending on what board your trying this with. The board I used and actually recommend is the REV B board but the REV H RF01/RF02 can work but I had some problems with these boards witch I will explain later.

Here above is the front of my RF board. The Covers on the ROL (Ring of lights) isn't needed it just made the lights look better when my front cover is on. 

The back of these can also vary a little bit but I circled the serial controller but you don't actually have to worry about that part specifically. Its interfacing with it is where the fun is.

Now that I have shown you what my board looks like, I can explain in detail how these work. So on the front of the board the RF module actually works on USB. Yes basic USB 2.0! This is pretty neat here because if you were to hook up 4 wires for the USB solder pads, your computer will recognize it as an unknown device but if you install the wireless receiver driver and point it to the unknown device it starts working right away. When in this state the board wont respond to any inputs, no lights, no response from the button, etc etc.. 

But how would I use a controller with it if it doesn't respond in this state? Well that is the catch. In order to use a controller you would need to first put the RF module into an Xbox 360, boot the console, then sync the controller and then plug the module back into your PC. You can turn the controller off and on by removing the batteries briefly but when you power it back on it will connect right away. Still though the board wont respond to inputs and that is where the Arduino comes in to play.

This is honestly my favorite part of how this thing works. Modders have found out that you can actually send data to the RF module and have it follow commands however it is NOT possible to receive data from the RF board such as controller battery status, or use it to control robots and stuff. I want to explain this a little bit, The Arduino and the RF module are technically two entirely separate things that have different tasks. When you are using the device to play games the RF portion works entirely on its own. 

Now say you are done or want to switch controllers. Here is what happens, you press the button on the RF board and it begins the sync animation like on a real Xbox 360 and at the same time you press the sync button on your controller and they bind after a few seconds. If you want to turn your controller off you simply hold the button for 4 seconds and release, the controller turns right off. The Arduino pretends to be an Xbox 360 and the RF Module simply obeys the commands.

The start up process is also interesting as well because the RF board actually has a little boot process of its own that it needs the Xbox 360 for. When you power the Arduino and the RF board at the same time the Arduino sends the "Initialize LED" command, but nothing visually happens but right after this the Arduino sends another command "BootAnim" witch is the normal Xbox 360 ROL start up sequence, the final step is to set the "PWR LED" witch makes it a steady green. This is to show that the board is powered on and ready. These steps are important regardless if you use the code I will provide (credit to the original writer of it at the end of the project) or if you write your own. Also the Despite the RF module being its own device during the Xbox 360 boot up process the Xbox 360 actually starts the communication with the module but after that its mainly the RF module sending data to the Xbox 360.

The serial side relies on a clock frequency that is either HIGH or LOW. I was Unable to get a proper formal reading on the actual clock frequency but it should be around 330hz HIGH or 30hz LOW. Your Arduino can see this but figuring this out is another project witch allows me to interface directly with the RF board over a USB to SERIAL adapter that when I can get it working properly I will do a write up on that. However I will link to a page that a user who goes by "Robot9706" made his own set up to manually control an RF Module via USB to serial directly without the Arduino. It is how I was able to test the clock frequency but unfortunately I could only do that as I was unable to get the RF board to respond to inputs but this could be resolved by using a REV B board since I only tried it with RF01 and RF02 Boards.

Here is the thread where he explains how he set it up and he posted a link with a folder that has all the tools and files for you to check out and try it yourself. I only used it for testing but I want to make a functional one as well. Link:  https://www.se7ensins.com/forums/threads/how-to-make-a-homemade-xbox-360-controller-wireless-receiver-for-pc.668839/page-14#post-9103564

To figure out what commands you can send to an Xbox 360 RF Module I will link a web page where a user named  "Peterbjornx" wrote a wiki page showing how the data works with the serial Micro-Controller. I will also borrow the diagrams for the USB pinout and the pin numbers from his wiki page for the assembly portion of this guide.

Link:  https://tkkrlab.nl/wiki/XBOX_360_RF_Module

That is about it for how it works, the code itself will reveal more but lets get to building the whole thing.

The 3 types of RF modules I attempted this project with are the REV H RF01/RF02 and REV B boards. The odd thing for me was a lot of people were able to get the REV H boards working but I could not, However for others the REV B was the difficult one to work with. You may have to try all 3 to get the right one that works off the bat as its not the code that is the problem its the boards themselves they can be really odd sometimes. Here is some pictures of the REV H RF01, RF02 and the REV B:

 

The backs of these wont matter much except where we will be soldering witch I will get to here soon.

Next lets take a look at how this will be wired up, the wiring is pretty simple but I do have to stress that its really important that the voltage is 3.3v going into the RF module as not only would it not work correctly going higher than this could damage the RF module and I did have some accidental casualties with this project, luckily RF boards are really cheap.

Here is a diagram of the pinout of where the USB wires go and same with the Arduino's:

The parts of the Arduino we will be using would be pin 2,3,and 4 on the PWM side, 3.3v pin, and the ground (witch also needs to be connected to the USB ground as well). I made a diagram showing where all the wires go. 

This is as simple as i can make the diagram but one thing I do want to say is that I tried this on two Arduino Leonardos and for whatever reason they could not see when the clock would change from high to low. This actually stumped me for a long time since I don't understand what it is about the UNO R3 that can see it but the Leonardo cannot. When the Xbox 360 Module starts up the CLK is high but when its done starting up it switches to low waiting for the next command. I did however get the Leonardo to actually start up the board and that is all i was able to get them to do.

For testing purposes I would strongly recommend harvesting the socket the RF module sits in from a dead Xbox 360 motherboard ( This is where a Hot Air Station would come in handy) because getting to the pins to solder to are a pain. You could solder test leads to the front but due to how heat resistant the solder joints are on the front and how close they are together make it rather difficult to work with and depending on what solder you use, your beads may want to stick together quite a bit. Here is the photo of the male side of the socket. See the metal shield? this is and obstacle. I actually just used needle nose pliers to remove it but you could try de-soldering it but it tends to absorb the heat and dissipate rather quickly but with patients and wigging gently at each of the solder points around the shield it will come off. Then once the shield is off you can gently pull the black pin divider off and have full access to the pins. In my build I did exactly this to make it as compact as possible for the 3D printed shell but you don't have to do this if you do not want to. 

I have borrowed a photo from iFix it for showing the front of the xbox 360 specifically the female RF socket so you know that it looks like. Using this socket will allow you to switch RF boards at will the only thing that makes it a little off putting is that each time you change the RF module you will have to set up the windows driver again. Do not install again, just go under device manager and point the driver back to the RF receiver. 

Here is the link for the microsoft driver and I will post screen shots of how to set it up because it doesn't automatically work out of the box after installing:  https://www.microsoft.com/accessories/en-my/d/xbox-360-wireless-controller-for-windows

Install this like you would any other driver software, Then plug in your Xbox 360 RF module to your computers USB port. In device manager you will see an Unknown device is listed there. 

Right-click on the device then click "Update driver":

Then click "Browse my computer for driver software":

Then Click "Let me pick from a list of drivers on your computer". Now you may have dig through an extensive list there but there will be a folder called something along the lines of "Xbox 360 wireless accessories". Here there will be quite a few options but the specific one in this list you want is the "Xbox 360 Wireless Receiver for Windows Version 10.0.18362.1". After confirming this device manager will refresh and your receiver will show up at the bottom of the list ready to go. If you bound a controller to this prior to messing with it you can fire up any games that support the Xbox 360 controller and test to see if its working correctly. 

If the module is working correctly then now you just need to get your Arduino ready. Simply plug the Arduino into the USB port on your computer, open Arduino IDE and select your board, COM port and then copy and paste the code that is in the code section of the project. The code does not need to be modified unless you plan on editing it for yourself or maybe trying to get it to work on different versions of Arduino boards.

Once flashed connect your Arduino leads to the board following the diagram above showing the whole layout. Then power cycle both the arduino and the RF module and if the assembly is done correctly the board should initialize and when its done starting up press the sync button (witch used to be the power button) and it should start the sync animation, if that is working then congrats! Your almost done here. 

Next is the enclosure. this is up to you on how you want to approach this but you can use the same design I used for mine witch may or may not need tweaked to use with more modern 3D printer software. Here is " Martin Ballantyne's" design and here is how his turned out for him since his pictures are cleaner and clearer than mine are. It fits the UNO R3 perfectly fine: 

Here is where you can download his Controller receiver folder that contains his code modifications, case design and the same photos I used here.

Link:  https://www.mediafire.com/file/z6b5k1n3s2n3u41/XboxControllerReceiver.zip/file 

Here is his code modifications. Simply Copy and paste this into Arduino IDE and upload to your Arduino and that is it.

  1. /* Arduino code to communicate with xbox 360 RF module.
  2. Original work by (yaywoop)
  3. Additional ideas from Alexander Martinez
  4. Modified by dilandou (www.dilandou.com, http://www.diru.org/wordpress)
  5. Controller turn off added by Martin Ballantyne using research from http://tkkrlab.nl/wiki/XBOX_360_RF_Module
  6. First sends LED initialisation code followed by LED startup animation code, then sleeps until a button press for sync command.
  7. If the sync button is held down and released after 1000ms the connected controllers will be turned off. Otherwise the sync command will initiate.
  8. 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.
  9. of course, make sure to have a common ground */
  10.  
  11. #include
  12.  
  13. #define sync_pin 2 //power button repurposed for sync button (pin 5 on the module)
  14. #define data_pin 3 //data line (pin 6 on the module)
  15. #define clock_pin 4 //clock line (pin 7 on module)
  16.  
  17. int led_cmd[10] = {0,0,1,0,0,0,0,1,0,0}; //Activates/initialises the LEDs, leaving the center LED lit.
  18. int led_timer_red_1[10] = {0,0,1,0,1,1,1,0,0,0}; //Set quadrant 1 to red
  19. int led_timer_red_2[10] = {0,0,1,0,1,1,1,1,0,0}; //Set quadrant 1 and 2 to red
  20. int led_timer_red_3[10] = {0,0,1,0,1,1,1,1,0,1}; //Set quadrant 1, 2 and 4 to red
  21. 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
  22. int led_red_off[10] = {0,0,1,0,1,1,0,0,0,0}; //Set quadrant 1, 2, 3 and 4 to off
  23.  
  24. int anim_cmd[10] = {0,0,1,0,0,0,0,1,0,1}; //Makes the startup animation on the ring of light.
  25. int sync_cmd[10] = {0,0,0,0,0,0,0,1,0,0}; //Initiates the sync process.
  26. int turn_off_cmd[10] = {0,0,0,0,0,0,1,0,0,1}; //Turns off the connected controllers.
  27.  
  28. volatile boolean sync_pressed = 0;
  29. int sync_hold_time = 0;
  30. boolean turn_off_controllers = false;
  31.  
  32. void sendData(int command[])
  33. {
  34. pinMode(data_pin, OUTPUT);
  35. digitalWrite(data_pin, LOW); //start sending data.
  36.  
  37. int previous_clock = 1;
  38. for(int i = 0; i = 1000)
  39. {
  40. sendData(led_timer_red_4);
  41. }
  42. else if(held_time >= 750)
  43. {
  44. sendData(led_timer_red_3);
  45. }
  46. else if(held_time >= 500)
  47. {
  48. sendData(led_timer_red_2);
  49. }
  50. else if(held_time >= 250)
  51. {
  52. sendData(led_timer_red_1);
  53. }
  54. else
  55. {
  56. sendData(led_red_off);
  57. }
  58. }
  59.  
  60. void initLEDs()
  61. {
  62. sendData(led_cmd);
  63. sendData(anim_cmd);
  64. }
  65.  
  66. void wakeUp()
  67. {
  68. sync_pressed = 1;
  69. }
  70.  
  71. void sleepNow()
  72. {
  73. set_sleep_mode(SLEEP_MODE_PWR_DOWN); // set sleep mode
  74. sleep_enable(); //enable sleep bit
  75. attachInterrupt(0, wakeUp, LOW);
  76. sleep_mode();
  77. sleep_disable(); //disable sleep bit
  78. detachInterrupt(0); // disables interrupt 0 on pin 2
  79. }
  80.  
  81. void setup()
  82. {
  83. Serial.begin(9600);
  84. pinMode(sync_pin, INPUT);
  85. digitalWrite(sync_pin,HIGH);
  86. pinMode(data_pin, INPUT);
  87. pinMode(clock_pin, INPUT);
  88. delay(2000);
  89.  
  90. initLEDs();
  91. }
  92.  
  93. void loop()
  94. {
  95. // Only sleep if the sync button is not held down
  96. if(!sync_pressed)
  97. {
  98. sleepNow();
  99. }
  100.  
  101. delay(200);
  102.  
  103. if(sync_pressed)
  104. {
  105. Serial.print(“Sync held time (ms): “);
  106. Serial.println(sync_hold_time, DEC);
  107.  
  108. setHeldLEDs(sync_hold_time);
  109.  
  110. // Count 1000ms, if elapsed the user wants to turn off their controllers
  111. if(sync_hold_time >= 1000)
  112. {
  113. turn_off_controllers = true;
  114. sync_hold_time = 1000;
  115. }
  116.  
  117. // Initiate the user’s action when they release the sync button
  118. if (digitalRead(sync_pin))
  119. {
  120. setHeldLEDs(0);
  121.  
  122. if(turn_off_controllers)
  123. {
  124. Serial.println(“Turning off controllers.”);
  125. sendData(turn_off_cmd);
  126.  
  127. turn_off_controllers = false;
  128. }
  129. else
  130. {
  131. Serial.println(“Syncing controllers.”);
  132. sendData(sync_cmd);
  133. }
  134.  
  135. // Action complete, reset hold time and button state
  136. sync_hold_time = 0;
  137. sync_pressed = false;
  138. }
  139. else
  140. {
  141. sync_hold_time += 200;
  142. }
  143. }
  144. }

Here is a list of my sources where I gathered all this information from all in one place anyone can check it all out too:

Link one:(the original Project source code by the user " Dil " : https://dilisilib.wordpress.com/hacking/xbox-360-rf-module-arduino/ (you can also see other users posts talking about using different types of Arduinos and they code they used and one person even used Raspberry Pi as well.)

Link Two: Microsoft Xbox 360 Wireless Controller Driver (Even though it says Windows 7 is the highest supported driver it works perfectly fine for me in Windows 10):  https://www.microsoft.com/accessories/en-my/d/xbox-360-wireless-controller-for-windows

Link Three: Martins folder containing the code and the 3D printer files (these may need converted for newer 3D printers):  https://www.mediafire.com/file/z6b5k1n3s2n3u41/XboxControllerReceiver.zip/file

Link Four: "Robot9706's" thread on using the USB to Serial adapter to manually control an RF module:  https://www.se7ensins.com/forums/threads/how-to-make-a-homemade-xbox-360-controller-wireless-receiver-for-pc.668839/page-14#post-9103564

Schematics and circuit diagrams

Xbox 360 RF Module and Arduino Whole Diagram

I tried to make this as simple as possible just make sure that the voltage going into the RF module is 3.3v and 5v going to the Arduino. It does make things a little easier if you power the Arduino and the RF module off the same USB cord

CAD, enclosures and custom parts

Case Part 1

This may need converted to work on newer 3D printers.

Case Part 2

This may need converted to work with newer 3D printers.

Case Part 3

This may need converted to work with newer 3D printers. Credit goes to Martin Ballantyne for making the design as it fits really well and is very durable. you will need a couple small screws for the USB cord holder. 4 for the back to hold the middle plate and the cover together and 3 for the RF module that screws into the middle palte.

Code

Martin's Code for Arduino UNO R3

I believe this can be used on any Arduino that has PWM pins but I can at least say this does work on Leaonardos (cant see clock change though) and works fully on the UNO R3

Credits

Photo of ViolentLambs

ViolentLambs

I'm just a guy who likes to build small projects in my free time and I like to share with the communities what I have made!

   

Leave your feedback...