Nintendo 64 Controller Interface Project
Team Members
- Marty Farren
Project Overview
Our intent was to use the Motorola 823 microprocessor to interface a Nintendo controller to a computer and then use this to play a Nintendo 64 emulation game. We’d be playing Nintendo 64 without a Nintendo 64. This required a large amount of hardware and a small assembly program. Using a standard Nintendo 64 controller, we use Xilinx to create hardware to poll the controller. The controller returns a pulse-width modulated signal that we need to run through more hardware to output a 32 bit value representing the buttons and analog stick. We then use SingleStep to send this data to a serial port so that the main processor can access the button values. This requires us to use special software that will transfer the serial port data into simulated keystrokes so that the emulator game can be controlled. Since this occurs approximately every 250 microseconds we can simulate actual controller use on the emulator.
Data Flow
- We begin by sending a “9 bit” pulse width modulated (PWM) signal to the controller to indicate we are ready to receive button data. The poll pulse is created with Xilinx hardware and sent to the controller’s bidirectional data bus through the 823 board.
- The controller returns a “32 bit” PWM signal indicating current button values. We use Xilinx hardware to sample the pulse and create a true 32 bit value of just ones and zeros.
- Since we are using the controller as memory-mapped I/O, we can read the button value into a register using a simple SingleStep program.
- Our SingleStep program analyzes the button values and sends corresponding ASCII values to the serial port using the UART device drivers.
- The main processor receives the serial data and uses the KeyInjector program to convert these to keystrokes that any Windows program will recognize.
- The Project64 emulator recognizes the keystrokes and moves the game character accordingly.
The Most Difficult
Issue
The biggest problem we encountered
was how to send the controller data from SingleStep
to the emulator. We wanted to originally
send the data through the parallel port but this proved to be too
complicated. The next idea was to
somehow use a PS/2 port and simulate keystrokes but this would be a whole
project on its own. The best solution,
which we used in the end, was to send the data serially and convert that into
keystrokes. The problem is that no
matter how fast you send the data, you cannot perfectly simulate a keypress, hold, and release. You can only simulate thousands of keytaps per second.
The emulator is fast enough to recognize the serial data as keytaps and therefore the analog stick is not as smooth as
it should be. Given 1-2 more weeks we
could have tried to interface the PS/2 port and simulate true keypresses.
Pictures
Links