An adversarial, 4 player version of the classic Nintendo game. Modeled after Super Bomberman 2. Used SDL graphics. Got both Power PCs on a Virtex 2 Pro board working, plus a fair number of hardware modules running on the OPB -- including a custom framebuffer.
Every Extend was a popular freeware game, since moved to the PSP (and updated to become "Every Extend Extra"). This group implemented it on the PowerPC, with hardware for supporting sound, video, random number generation, etc.
The first attempt at making an OpenGL Acclerator -- a device which would input instructions in the standard OpenGL language and output images to the monitor. In theory, such a device could be used for many games, as OpenGL is pretty common. This team built what they believe to be an architecturally complete version of the accelerator. Unfortunately, it wouldn't synthesize into anything that would fit on the Virtex II Pro board.
The first attempt at making the Nintendo Entertainment System (NES), an 8-bit console from the mid 1980s. Unfortunately, the team was unsuccessful.
This group built a 2-dimensional physics processing unit to model motion of particles (given position, velocity, acceleration, rotation, orientation), collisions (elastic/inelastic) between particles, effects of gravity, and wind resistance. They built a simple 2-player shooting game to demonstrate.
This team ramped-up the classic PacMan game by making it a first-person, virtual reality game An OpenGL workstation interfaces with a virtual-reality helmet. The PowerPC on the Virtex II Pro board interfaces with a custom built chair (which acts as a PS2 mouse as the person leans back and forth), updates game state, runs the ghost AI, and then sends data to the OpenGL workstation for a VR helmet render.
This team ported the open-source version of Guitar Hero, "Frets on Fire", to the Virtex II Pro board. They interfaced the guitar controller via a PS2 adapter. They also ported 3 songs and made the audio hardware to play each song.
A second attempt at building the NES. Unfortunately, this team didn't get a working system. Note that their report is filled with information, but isn't necessarily all that useful as it doesn't have much description of how that information fits together, how the team used it, nor how it actually works.
A fully-playable port of Quake, including networked multiplayer support for LAN play. Game sounds are mixed and rendered with the AC97 codec. A pretty impressive, completely successful, project.
This game was designed by the student group, with the design goal of being extremely parallelizable. It is a generic version of resource collection and peon creation game. It ran on the Power PC, with a custom particle management/combat resolution/rendering pipeline.
Finally, success on the NES front. This was a pretty incredible team that really worked well together, contributing hugely to their success. They eschewed the Virtex II Pro's PowerPC entirely, building a 6502 processor, the Pixel Processing Unit (a very basic GPU), an audio processing unit and a DMA manager. For their effort, this team won the David Tuma Award for the best undergraduate project of the year.
This team got the original Descent game working on the Virtex II Pro board. They ported code to the PowerPC, built a framebuffer and added audio support. The result was a very playable version.
This team built a custom version of asteroids, using the Wii remote for input. The Wiimote used Bluetooth to communicate with a Linux laptop, which transmitted the input messages over Ethernet to the Virtex II Pro board.
This team, like the F08 XilRoids team, aimed to get the wiimote working. They also had to do an end-around by sending the wiimote bluetooth signals through an intermediary computer. The duckhunt game was re-coded and worked fairly well.
This team attempted to get the GameBoy Color console working, including link cable for multi-player capability. They had to back off to the Original GameBoy (monochrome) and were able to get Tetris "sort-of" running without sound or link cable.
This team worked on a console that emulates multiple arcade games built by the Williams company, a style commercially known (and sold) as "MultiWilliams". The single system would then support 4 classic arcade games: Joust, Robotron, Stargate and Defender. They built a very nice input system with arcade quality hardware (joystick, buttons, etc) which is available for new teams.
This project attempted to build the OpenGL accelerator -- to render images specified using the OpenGL language. Unfortunately, the final attempt was less than successful, with a very slow frame rate.
Using the new Virtex-5 boards, this team had a speedy enough processor to port Quake II, on top of a commercial Linux distribution (LinuxLink). They were working on a hardware matrix pipeline when they ran out of time.
This team attempted a research project (as opposed to a game project) for Prof Ken Mai. The project was to build a Solid State Disk Drive. They laid out and had constructed a DIMM with flash chips on it. They then used a microblaze processor on a Virtex-5 board to develop the flash controller. They got some form of PCIE communication going between the host processor and the FPGA board, but did not get the entire project completed.
This team also attempted the SSD drive project for Ken Mai. They got some very basic communication going with the flash chips, but the controller did not do most of the management algorithms. This group's project report is very good, with lots of good words of wisdom -- even for those not doing SSD projects.
Another attempt at the OpenGL Accelerator GPU. This team got further than any previous, though still not what anyone would call an acceptable GPU. Their pipeline worked, with small triangle-count objects getting drawn with decent framerate. However, the z-buffer didn't work and so had to be turned off for the final demo. No attempt was made to get a shader working.
This group did something very interesting (and quite legal) -- they got a synthesizable Verilog description from the company that originally manufactured the CPU. With monor modifications, it was ready to go. Unfortunately, this group fell victim to the "not enough time to integrate" monster and ended up with separate descriptions of the system's chips. Without integrating the chips together, however, they did not have a complete system to demonstrate.
This team attempted Ken Mai's SSD project. They got really stuck on picking up the pieces of the previous projects and did not make much progress. They also had some team issues that really caused problems.
This group wanted 18-545 to integrate well with 18-447, Computer Architecture. Therefore, they focused on the designing an ARM-like CPU and then ported a small musical rhythm game to it. This was the most successful project of the F10 semester.
Doom is perhaps the primary antecedent for today's first-person shooter games. This group ported it to the MicroBlaze processor on the V5-LX100T board. They did not get the networking aspects or background sounds working, but otherwise it was a successful project.
The Commodore 64 was a very, very, extremely popular and best-selling personal computer of the pre-Wintel age. This group built the C64 in hardware. They got 5 different games running (for some definitions of the word running). They also got the Basic Interpreter running, so programming the chip in the BASIC language is possible. This was a very successful project.
This group attempted to build a complete computer system in Verilog, including lots of the computer architecture and OS issues. The computer is a MIPS architecture and is capable of running MIPS machine language and interacting with several peripheral devices. The group wrote a C implementation of the classic Duck Hunt game. Unfortunately, the OS kernel was incomplete and thus never actually executed the game. Beware of attempting too much.
This team built a music visualizer controlled by an XBOX Kinect. Given arbitrary music input, the system produced several very nice images based on facets of the music (beat, amplitude). The user could gesture to the Kinect to control the type of waves, colors, shapes, etc.
This group started out building a graphic image correlation tool for use by the LunarX Prize research group in the Robotics Institute. They eventually discovered that the code given them for the algorithm was incomplete, so they pivoted and created a more general-purpose FPGA based data processing device. The primary contribution of the project was to develop the PCI-E interface and document its use in good detail. Any project attempting to use the PCI-E interface should spend some time reading this report carefully.
This project was a stunning success. It was an implementation of the classic arcade game 1942, a vertically scrolling game from late 1984 set in the Pacific Theater of WWII. The player flys a P-38, shooting down enemy planes and avoiding enemy fire. The group won first-place in a competition with prizes from Apple. Much of their success is due to good engineering decisions and completing their work before Thanksgiving. With the extra time, they polished the project, including use of the arcade joystick and bezel artwork.
Based on their team name, one might reasonably suspect an implementation of the much-beloved Defender arcade game. Unfortunately, this team chose to implement an Apple IIe instead of Defender. The team originally worked on their own implementation of the 6502 CPU chip, but eventually decided to use an open design instead. Also on the original idea list was to get a floppy disk emulator constructed, but that fell by the wayside as well. The team did get the Apple IIe constructed to the point of the basic interpreter. Some group issues kept the team from fully conquering their goals.
Another group to attempt the Apple computer, these guys tried building the Apple IIgs variant. Also quirkily named, after the famous Oregon Trail destination. This team got a bootable IIgs System Monitor and were able to show memory and CPU register contents. This group spent quite a bit of time with the complexities of the disk drive subsystem.
This team team attempted the GameBoy Color system (also attempted in F09). The GameBoy Color was a wildly-successful handheld from Nintendo in the late 90s. The architecture is fairly complex, and the team had trouble with memory bank switching and the cartridge interface. They were able to (carefully) design a custom game that avoided buggy instructions and memory addresses.
The Sega Genesis was a 16-bit game console that was popular during the early 90s. This team created a fully-functional console, including sound and controller interfaces. This team accomplished just about everything that one would wish in a console emulation. The system can run any game console, or toggle to games loaded from the on-board Flash memory. The system is architecturally complex, with 5 processors and three memory modules. An excellent job!
This team designed and constructed a ray tracer that would display VGA resolution rendering of a scene described with a KD tree. The scene is loaded from an attached computer using XMODEM protocol over a serial link (at 115Kbps). The scene is re-rendered any time a camera change occurs. The project is a really good example of the research-type 545 project, where the entire design is up to you. This team iterated design components multiple times, resulting in a very solidly successful project. The group won second-place awards from Apple, Inc.
This team designed and implemented a coprocessor that would do visual odometry calculations for robotic pose estimations. This project included a PCI interface and a fairly severe math unit. While not entirely successfully implemented, it is still a pretty impressive piece of work.
The classic Donkey Kong arcade game, fully implemented, fully playable. A very fine project.
Yet another assault on the Game Boy project. This team got a mostly-functional Game Boy implemented. It uses a cartridge connector, though only Tetris seems to work properly. The game is playable, including most of the sounds. There were a few bits missing in the GPU and the link cable did not work reliably. Otherwise, a complete project.
Yes, you read that correctly -- this team attempted to build a playstation. Certainly a high goal. Luckily, the team was very flexible and able to adapt after issues arose. They banged their heads against the HDMI interface on the Vertex-7 boards for a while, then shifted to the Altera DE2-115 boards from 18-240. They also shifted the project into a mostly GPU system. They did paint the fence, though, so there is that.
This team attempted to build the Super NES system and ran into some of the same issues as the F10 team. They got permission to use the CPU models from the industry contacts and built many of the chips. They had problems integrating the CPU and the GPU, though they were able to show that elements of the system were working. They did have one of the best cases for the demo day, however.
This team went into the wayback machine to pull out one of the early consoles. The Atari 5200 SuperSystem is a console from 1982, the third generation of Atari consoles. This team built a fully-working with a cartridge interface and proved it worked on three physical cartridges. This is a 6502 CPU project with several support chips, built on a Virtex-5 LX110T board.
This team built a 32-channel, 100MHz DLA. This team was one of the first to really attack a SOC Zynq chip project. They used the high-performance ZQ706 board, got Linux running with a web-server for a user interface. The logic fabric was designed to sample signals, compress the information and do some preliminary protocol analysis.
This team was one of the first to push on the digital signal processing capabilities of the FPGA. They built a hardware digital synthesizer. The goal was a MIDI interface with tone generation all done in the FPGA fabric, parameterized by knobs and sliders. This is a ZedBoard project using a PMOD audio codec.
This Game Boy Color project was a mostly complete implementation which could play most GBC and Game Boy games from a Flash cartridge emulator. Their target game, Pokemon Crystal, ran flawlessly (including demonstrating a known bug in the commercial cartridge). The board was a Vertex 5.
Extending the number of computer systems that have been built in this class to the IBM 5150, the original IBM PC, this team covered all the major subsystems other than the disk drive in a Virtex-5 LX-110T board.
This team attempted to build the N64 (minus a specialty graphics processor) to be able to run select cartridges.
An Atari 7800, using some base design materials from an extreme Atari enthusiast on the internet.
A well-done version of the arcade classic, complete with cabinet. The team paid special attention to the vector graphics engine, producing something very close to the original.
The team took on Marble Madness and eventually scaled back to an implementation of the arcade classic, Centipede.
The first team to take on a project in 545 with the main goal of collecting, analyzing, and filtering ethernet traffic.
This team produced a nearly-all-the-way working version of the MorphCore research computer architecture, including basic software running on their CPU.
A custom neural network handwritten digit classification system. The system consumed real-time video and produced on-screen classifications of arbitrary, hand-written digits.
The classic arcade cabinet rendered in an FPGA.
An adaptation of visual odometry, which is used to help robots figure out where they are and where they are going.