Note: This is an outdated project. I’m working on a cheaper bluetooth controller. A lot of information in here will carry over to the new tutorial, though, so feel free to familiarize yourself.

I was playing Mega Man 2 in my living room on my NES, sitting just far enough away from the console that the cable for the controller was taut. Nearly pulled the NES off of the table. A problem from a simpler time, I thought. I could get this to be wireless, surely!

So I got to looking online for solutions.

Well… I found this. But I’d rather make my own. It’ll be a fun little electronics project!

Not counting the 3D printed case and smaller parts like resistors and capacitors, I spent overall about $40 on this project. Here’s what we’ll need:

1) One NES controller

2) Two ATMega328 processors (and an accompanying Arduino board to program them)

3) One wireless transmitter and receiver pair (about $10)

4) A shift register (such as the CD4021, which just so happens to be used by the controller)

5) Battery charging circuit

6) Lithium ion battery (I used a 330mAh battery, but even something as small as 100mAh will still get you ample play time – make sure it can fit in the controller!)

7) Protoboard

8) A switch – I used these, but you can use your own and drill a hole in the model for it

9) Miscellaneous components (resistors, capacitors, 16MHz crystal oscillators, and LEDs)

You’ll also need access to a 3D printer. If you’re still in school, check to see if you can get 3D printing services. If they don’t, you can send it out to get it made on some website, or you can order one from me! Just email me (thepoorstudenthobbyist@gmail.com) with the model you want, and I’ll get back to you on a price and time frame. I might even do some custom orders, if you ask nicely, and don’t have outlandish requests. Currently I can only print in white, though. But you can paint it if you wanna. Here’s the Thingiverse entry for the controller and the receiver.

I bought most of my supplies on eBay from China. It takes a few weeks to get here, but the savings can be great for the simpler things. As a quick comparison, you can buy a single ATMega328 on Amazon, Adafruit, or Sparkfun for upwards of $5, or you could buy a five pack from China for little more than $10.

The transmitter and receiver seem to be best available at Sparkfun, so you might want to consider buying the battery and battery charger from there as well to cut down on shipping costs. The only part of this tutorial that would be slightly different is for the battery charging circuit.

A note on the batteries – make sure your battery will fit inside the controller. A 2000mAh is awesome, but complete overkill. And definitely won’t fit in the controller I’ve designed. Keep it under 500mAh and you should be good. The space provided in the controller is about 1″ x 1.5″.

Enough boring exposition – let’s kick off this journey by learning how the controller actually works. If you’re so inclined to skip the prototyping steps and just build the controller, skip to the “Expanding the Transmitter Test Unit” section.

How the NES Controller Works

The NES controller is surprisingly and satisfyingly simple, actually. It uses a single IC – the CD4021. Just a simple shift register. The schematic for the controller is below.

Note: When figuring out which wires correspond to which pins on the controller port, do NOT trust any color diagrams you find online. Mine did not match the one I found, and it turns out Nintendo changed the convention a few times. The easiest thing to do is use a multimeter and figure out which wires go where.

If you are wondering, I use TinyCAD for schematic drawing.

So each button on the controller corresponds to a different digital input into the shift register. The NES sends a pulse through the latch wire (on the P/S pin) at a rate of 60 Hz, or once per 16 ms. When the shift register receives this pulse, it takes the states of the buttons and sends it through pin 3 (Q8, labelled as “Data” above) as serial data. The rate at which this data is sent is determined by the clock speed, on pin 10 (approximately 83 kHz, sent from the NES). The NES will take this serial data from the data wire. The data is analyzed from the pulse train, the state of each button is determined, and the game takes care of the rest from there.

A timing diagram for the NES and the controller. The NES sends the latch and clock pulse trains, the controller sends the data pulse train. In this example, the B and Left buttons are pressed. Note that a pressed button is represented by a low signal.

If this explanation isn’t sufficient enough, here’s a more in-depth explanation of shift registers. If you know how they work, you can skip ahead.

Each button is either on or off. This is classically defined as a 1 or a 0, however in the case of the controller, they decided it was easier to set on as a 0 and off as a 1 (a “1” state is 5V, a “0” state is 0V). This achieved using the resistors R1 through R8 (which are known as “pull-up” resistors, because they pull the signal up to 5V) which are paired with the buttons. When the button is not pressed, the circuit is not completed, forcing the pin on the shift register to 5V from the supply. When the button is pressed, the pin is grounded, forcing it to 0V.

The states of these 8 buttons, reading either 5V or 0V, are collected by the shift register. When the P/S pin is activated by the NES using a small pulse, a snapshot of the button states is taken, and is fed through the serial output as a string of 8 bits (or a byte). This string of 8 bits would be represented by an oscillating square wave, if you were to look at the signal on an oscilloscope. Once the 8 bits have been fed through and read, the NES sends the pulse again to take the next snapshot. So, if you were playing Super Mario and you were running to the left (so holding the B button and the left D-pad), the byte would read 10111101.

Make sense? It’s not complicated once you get the hang of it. It’s worth mentioning that the data going into the shift register (8 separate pins) is known as “parallel” data, and the data coming out (one single pin) is known as “serial” data. This is a good idea, because otherwise there would be 7 more pins coming out of the controller port if they decided to go only the parallel route.

So here’s how our overall system will work. The NES controller will send its button presses to the digital pins of the transmitting ATMega328. This transmitter will send the button presses wirelessly, as a byte, to the receiving ATMega328. This receiver will analyze the byte, determine which buttons were pressed, and mimic those button presses to the shift register through eight digital output pins. The NES will then read the parallel data on the shift register and receive it as serial data as it would a normal NES controller.

Simple, right?

If this picture doesn’t make it look simple, nothing will.

The Beginnings of the Receiver

Now that we know how the controller works, we can begin to make the receiver end of the wireless controller. You’ll need a CD4021 shift register. They’re widely available today, even though they’re 30-something years old. I found a bunch at my local electronics hobby shop, or you can buy them online for about $0.50 (I recommend eBay if you don’t mind waiting for things from China – I got about 10 for a buck). The Arduino IS capable of sending serial data to the NES, which would eliminate the need for this external shift register, but this way to me is easier to program and troubleshoot without more expensive equipment (like an oscilloscope).

The CD4021 chip makes this baby hum. It’s not humming a very complicated tune, either.

Now that we have the shift register, find ten resistors to use as pull-ups (shown as R1 through R10 below). I used a few 10kΩ resistors myself, since I had a lot lying around, but most sizes between 1kΩ and 50kΩ should work fine, since we’re not using current to control our ATMega. You’ll want to keep the resistor size above 1kΩ, as lower resistances might pull too much current from the NES. The wiring schematic I used is shown below.

R11 is connected to a pushbutton, used to start the program used for debugging. In the final product, this button will not be used. I used pins 2 through 9 to correspond with the buttons shown in the previous post. Use the table below for reference.

The NES reads the button states in this order: A, B, Select, Start, Up, Down, Left, Right. It’s important that we use this order of buttons in our program and keep the pins consecutive. This will become apparent later in the tutorial.

I’ve cut off a controller port from our controller, and soldered new wires to the small ones to put in a breadboard.

What the board will look like after wiring up the controller port. The three LEDs are from another project, and it is not necessary to use them.

After connecting everything shown in the schematic above, you can run a test program. For my program, I simply flashed the start button on and off every two seconds. The code I loaded into the Arduino to test this is below.

NOTE: Be sure to disconnect the USB cable from the Arduino when plugging it in to the NES – otherwise power will backfeed into the NES from the controller connector. When you turn the NES on, the Arduino will turn on from power coming through the 5V pin on the connector.

//Presses start button on and off every two seconds
 int right=2;
 int left=3;
 int down=4;
 int up=5;
 int start=6;
 int select=7;
 int b=8;
 int a=9;
 int button=11;
 int ledpin=13;

void setup(){
 pinMode(right,  OUTPUT);
 pinMode(left,  OUTPUT);
 pinMode(down,  OUTPUT);
 pinMode(up,  OUTPUT);
 pinMode(start,  OUTPUT);
 pinMode(select,  OUTPUT);
 pinMode(b,  OUTPUT);
 pinMode(a,  OUTPUT);
 pinMode(button, INPUT);
 pinMode(ledpin, OUTPUT);
 digitalWrite(right, HIGH);
 digitalWrite(left, HIGH);
 digitalWrite(down, HIGH);
 digitalWrite(up, HIGH);
 digitalWrite(start, HIGH);
 digitalWrite(select, HIGH);
 digitalWrite(b, HIGH);
 digitalWrite(a, HIGH);
}

void loop(){
 //Wait til button is pressed
 while(digitalRead(button)==LOW){
  digitalWrite(ledpin, LOW);
  delay(100);
 }
 while(1){
  digitalWrite(start, HIGH);
  digitalWrite(ledpin, LOW);
  delay(1000);
  //Flash led connected to pin 13, and emulate start button press
  digitalWrite(start, LOW);
  digitalWrite(ledpin, HIGH);
  delay(1000);
 }
}

Pop in your favorite game, and see the game respond to your start button presses! Now if you want, you can program in other button presses. You can even, oh I don’t know, program it to run the first level of Super Mario Bros.

While waiting for my wireless dongles to come in the mail, I made this neat little program. The LEDs on the breadboard were used for debugging. Red LED indicates pushing the A button to jump, yellow LED indicates program is running in the main loop, and green LED was just to signify the end of the program.

This receiver will be modified before the final product, but it’s a good start for now. Let’s delve into the wonderful world of wireless wonders.

Preparing to Test the Wireless Communications

Now it’s time to try out your dongles (heh). The two devices I bought are very easy to interface with, especially with the VirtualWire.h library for Arduino that exists for many such devices. You’ll need to download and install this library to the Arduino IDE.

For this step, you’ll either need two Arduinos, or you could use an ATMega328 processor on a breadboard. I chose this path, since I only have an Uno at my disposal. But how do you use an ATMega on a breadboard, I hear you ask. Luckily, I have an answer for you in the form of a schematic.

No way it’s that easy!

That’s all you need. Just connect your 5V and GND wires to a power source (I use the power pins on the Arduino board while prototyping). R1 holds the RESET pin high to 5V – this will keep the program running. X1 is a crystal oscillator, which drives the clock signal to the processor – I used a 16MHz crystal, which is standard for the 328. The crystal also needs two 22pF (or whatever you can get closest) capacitors for stabilization. The LED is just a power indicator.

AREF is the reference voltage used for scaling the analog inputs, and AVCC is used for the analog pin power. Since we won’t be using these pins, just tie them to VCC.

Note that the pin numbers don’t correspond to the pin names – for example, D0 (digital pin 0, or the RX pin) is pin 2. D7 is pin 13. In the future, be sure to connect to the correct pins.

But how do you put this code onto your ATMega without an Arduino? Simple. Just put the ATMega into the Arduino Uno and upload your program. Then, remove the chip and place it on your breadboard. You’ll want to be sure that you can easily insert and remove the processor at will, should you need to reprogram anything. You’ll also need to ensure you put the chip in with the correct orientation.

Most ATMega328s are preloaded with the Blink test code. Hook up an LED to D13 (pin 19) to check. If you get nothing, then program the Blink code into your ATMega and try again.

If the Blink code still isn’t working, try removing the two 22pF capacitors – your breadboard might have enough internal capacitance to keep the timing accurate, and the added capacitance might screw up the oscillator. You’ll need to add them back in if you plan on moving to a printed circuit board or a more permanent soldered protoboard.

Setting up the Transmitter Test Unit

I’m going to use this separated ATMega to drive the transmitter module. This is because we’ll want to read what the receiver is…. receiving… by using the Serial Monitor. So here’s how you’ll want to wire the transmitter side.

Again, pretty simple. Make sure you don’t flip the pins on the transmitter.

I’ve re-purposed some sample code I found online to test our setup. The code below will simply send an arbitrary number to the receiver. The receiver will be connected to our COM port to read through the serial monitor. It’ll only print the number if it receives it, because the VirtualWire.h library sends a check to the receiver, so you’ll know if it’s actually transmitting or not. Here’s the code that you’ll load into the ATMega of the transmitter.

// Transmitter Test Unit Code
 #include <VirtualWire.h>
 byte number=170; //Arbitrary binary number (10101010)

void setup(){
 // Initialise the IO and ISR
 vw_set_ptt_inverted(true); // Required for specific model, you probably don't need this
 vw_setup(4800); // Maximum bits per second recommended by manufacturer
}

void loop(){
 // Sends the binary number once every second
 digitalWrite(13, true); // Flash a light to show transmitting
 vw_send(&number, 1);
 vw_wait_tx(); // Wait until the whole message is gone
 delay(100);
 digitalWrite(13, false);
 delay(1000);
}

// Receiver Test Unit Code

#include <VirtualWire.h>
byte number;

void setup()
{
 Serial.begin(9600);
 vw_setup(4800);     // Maximum bits per second recommended by manufacturer
 vw_rx_start();       // Start the receiver PLL
 pinMode(13, OUTPUT);
}
void loop(){
 digitalWrite(13,false);
 byte buf[VW_MAX_MESSAGE_LEN];  // sets variable for received message
 // VW_MAX_MESSAGE_LEN is equal to 80, it is a constant in VirtualWire.h
 byte buflen = VW_MAX_MESSAGE_LEN;  // sets maximum message length
 if (vw_get_message(buf, &buflen)){ // Checks to see if the message was received
 // and if it was within than the maximum length
  digitalWrite(13, true);
  number=buf[0];
  Serial.println(number, BIN);
 }
}

Load it up, make sure power is being delivered to your transmitter. Pull open the Serial Monitor, you should be getting a steady signal of  “10101010”. If you’re not receiving this byte, make sure you have the baud rate set to 9600 in the Serial Monitor, make sure everything is wired up correctly and all the appropriate LEDs are on or flashing, and that you have the transmitting ATMega on the breadboard and the receiving ATMega on the Arduino.

Here’s my setup at this point. The transmitter is using the standalone breadboard with ATMega, seen on the back left. The receiver dongle is on the breadboard on the right, and the Arduino with receiver code is on the front left. It is connected via USB to my computer so that I can read the received data through the Serial Monitor.

Expanding the Transmitter Test Unit

Once you’ve verified that the receiver is getting the test number 10101010, it’s time to expand it to transmit the NES button presses. To do this, we’re going to emulate an NES with our microcontroller. As I discussed earlier, the NES sends out a signal through the latch wire, which is received by the shift register. The shift register then sends back the states of the buttons in the form of serial data at the rate sent through the clock wire.

You’ll need to take your controller cable that you cut up earlier, and extract the five wires coming out of it. I soldered on new wires and taped the bare wire, and then put them into the receiver breadboard. The power line should go to the 5V rail, the ground wire should go to ground, and I put the clock on pin 8, the latch on pin 7, and the data on pin 6.

The only real addition is the NES controller wires on the left.

// Final Transmit Unit Code

#include <VirtualWire.h>

int clock = 8;
 int latch = 7;
 int data = 6;
 int x;
 byte nespad = 0;

void setup(){
 // Initialise the IO and ISR
 vw_setup(4800);     // Maximum bits per second recommended by manufacturer
 pinMode(clock, OUTPUT);
 pinMode(latch, OUTPUT);
 pinMode(data, INPUT);

 digitalWrite(clock, LOW);
 digitalWrite(latch, LOW);

 Serial.begin(9600);
}
void loop(){
 digitalWrite(latch, HIGH);
 delayMicroseconds(12);
 digitalWrite(latch, LOW);
 // The Latch has now been sent, so send clock signal and read the button states
 for(x=0;x<8;x++){
  digitalWrite(clock,LOW);
  delayMicroseconds(4);
  nespad = nespad << 1; // Shift the bits of nespad to the left
  nespad = nespad + digitalRead(data); // Add the new pin state, either a 1 or 0
  digitalWrite(clock,HIGH); // Next button state is output to the data line
  delayMicroseconds(4);
 }
 digitalWrite(clock,LOW);

 digitalWrite(13, true); // Flash a light to show transmitting
 vw_send(&nespad, 1);
 vw_wait_tx(); // Wait until the whole message is gone
 delay(1);
 Serial.println(nespad, BIN);
 digitalWrite(13, false);
}

// Final Receiver Unit Code

#include <VirtualWire.h>

byte number;

int A = 9;
int B = 8;
int Select = 7;
int Start = 6;
int Up = 5;
int Down = 4;
int Left = 3;
int Right = 2;

int x;

void setup(){
 Serial.begin(9600);
 vw_setup(4800);     // Maximum bits per second recommended by manufacturer
 vw_rx_start();       // Start the receiver PLL running
 pinMode(13, OUTPUT);

 pinMode(A, OUTPUT);
 pinMode(B, OUTPUT);
 pinMode(Up, OUTPUT);
 pinMode(Down, OUTPUT);
 pinMode(Left, OUTPUT);
 pinMode(Right, OUTPUT);
 pinMode(Start, OUTPUT);
 pinMode(Select, OUTPUT);
}

void loop(){
 digitalWrite(13,false);

 byte buf[VW_MAX_MESSAGE_LEN];  // sets variable for received message
 // VW_MAX_MESSAGE_LEN is equal to 80, it is a constant in VirtualWire.h

 byte buflen = VW_MAX_MESSAGE_LEN;  // sets maximum message length

 if (vw_get_message(buf, &buflen)){ 
  // Checks to see if the message was received
  // and if it was within than the maximum length
  digitalWrite(13, true);
  number=buf[0];
  Serial.println(number, BIN);
  for(x=0;x<8;x++){
   // This code reads each bit in the received byte
   // Depending on the bit, the corresponding pin, which is two places
   // ahead of the number in the loop, is toggled high or low
   if (bitRead(number,x)==1){
    digitalWrite(x+2, HIGH);
   }else{
    digitalWrite(x+2, LOW);
   }
  }
 }
}

Your final schematic for the receiver. If you’d like, you can remove the LEDs, if you are sure it works.