FPGA Snake Game Uses No VHDL At All

January 20, 2012 by Mike Szczys 18 Comments

We’re really not supposed to start a feature like this; but this hack is awesome. It’s a game of Snake implemented by an FPGA dev board. It uses a 16×16 LED matrix as the display and an SNES controller for input. So far it sounds like a very normal version of the game. But as you start to hear how it works in the presentation after the break you fall in love with what’s going on here.

First of all, it’s not written in VHDL — the predominant programming language for FPGAs. Instead, [Darrell] used the schematic-only approach to build the logic. Okay, that’s starting to get more interesting. As he continues to explain the circuit we get to see how the control input works (pretty simple since the SNES controller uses a parallel-to-serial shift register) and how the display is multiplexed. But the actual game logic is where things really take off. Each pixel in the display has its own individual logic circuit. Basically every cell is its own processor which reacts both to what is passed into it, as well as to a random seed. That seed system is called the ‘bucket brigade’ and passes a chance to spawn a piece of food from one cell to the next. All of this together makes for one simple game that is eloquently executed. Continue reading “FPGA Snake Game Uses No VHDL At All” →

Two Player Space Invaders Via FPGAs

January 3, 2012 by Brian Benchoff 8 Comments

Last semester, [Peter], [Jared], and [Jeremy] took a course on embedded systems. They managed to turn out a very accurate copy of the classic Space Invaders in their class. Not wanting good code to go to waste, they decided to develop two player Space Invaders, and we wouldn’t mind testing it out.

The guys built their Space Invaders clone on a Virtex II dev board. Wanting a little more hardware development, they picked up a pair of RF trancievers so the two boards could communicate with each other. The rules of two-player Space Invaders is fairly simple; if you destroy an alien, there’s a 30% chance it will appear on your opponent’s screen. Hit the space ship that flies along the top of the screen, and 1 to 7 aliens will appear on the opponent’s screen. It’s a bit like two player Tetris where your victories bring about your friend’s downfall.

The guys put a really neat spin on an old game, and we’d love to try it out. Check out the guy on the left losing a game of Space Invaders to his lab partner after the break.

Continue reading “Two Player Space Invaders Via FPGAs” →

So You Wanna Learn FPGAs…

December 30, 2011 by Brian Benchoff 44 Comments

FPGAs are the bee’s knees. Instead of programming a chip by telling it what to do, FPGAs allow you to tell a chip what to be. Like everything though, a new skill set is needed to fully exploit the power of FPGAs. [Mike Field] decided to give back to the internet community at large and put up a crash course in FPGA design.

Right now, [Mike] has a couple of modules up that include subjects like binary math, busses, counting, and of course setting up the FPGA hardware. The recommended hardware is the Papilio One, although the Digilent Nexys2 is what [Mike] has been using so far.

We’ve seen a ton of awesome stuff that uses FPGAs, like the emulated Mac Plus, breaking HDCP, and an Ocarina of Time. [Mike]’s tutorials look like a great starting point for some FPGA work. [Mike] is also looking for some feedback on his tutorials, so if you’ve got an idea of what he should cover be sure to drop him a line.

EDIT: ~~The server was running on an FPGA and we can’t find a cache anywhere. If you’ve found a mirror, send a message.~~ Apparently Amazon’s EC2 runs on an FPGA.

Building The Ocarina Of Time With An FPGA

December 13, 2011 by Brian Benchoff 8 Comments

[Joe] and [Evan] wanted to have some fun with their FPGA course at Cornell. When faced with what to do at the beginning of the semester, they figured additive synthesis was a worthy pursuit. They ended up building the Ocarina of Time for their final project.

The guys started by recording a real ocarina and figuring out the relative power levels of each harmonic. Because any sound can be synthesized from a bunch of sine waves, having their Altera FPGA board replicate those frequencies produces a nice ocarina sound

[Joe] and [Evan]’s ocarina has a ‘mouthpiece’ that is just a small microphone. This mic is hooked up to the FPGA board and controls the volume. Sadly, the guys didn’t have time to take apart an N64 controller so 6 red buttons serve as the finger holes.

From the video after the break, [Joe] and [Evan] really pulled together something that sounds like Link’s Ocarina. Great work, guys.

Continue reading “Building The Ocarina Of Time With An FPGA” →

Get Ready To Play Some Wicked Air Harp

December 12, 2011 by Mike Szczys 10 Comments

Who needs a tactile interface when you can wave your hands in the air to make music? Air String makes that possible and surprisingly it does so without the use of a Kinect sensor.

In the image above, you can see that two green marker caps are used as plectra to draw music out of the non-existent strings. Judiciously perched atop that Analysis and Design of Digital Systems with VHDL textbook is a camcorder recording an image of the player. This signal is processed by an FPGA (hence the textbook) in real-time, and shown on the monitor seen to the right. A set of guides are overlaid on the image, so the player knows where to pluck to get the notes she is expecting.

The program is designed to pick up on bright green colors as the inputs. It works like a charm as you can see in the video after the break. The team of Cornell students responsible for the project also mention a few possible improvements like adding a distance sensor (ultrasonic rangefinder?) so that depth can be used for the dynamics of the sound.

Continue reading “Get Ready To Play Some Wicked Air Harp” →

HDCP Falls To FPGA-based Man-in-the-middle Attack

November 30, 2011 by Mike Nathan 49 Comments

fpga-hdcp-maninthemiddle-attack

It’s been a little while since we talked about HDCP around here, but recent developments in the area of digital content protection are proving very interesting.

You might remember that the Master Key for HDCP encryption was leaked last year, just a short while after Intel said that the protection had been cracked. While Intel admitted that HDCP had been broken, they shrugged off any suggestions that the information could be used to intercept HDCP data streams since they claimed a purpose-built processor would be required to do so. Citing that the process of creating such a component would be extremely cost-prohibitive, Intel hoped to quash interest in the subject, but things didn’t work out quite how they planned.

It seems that researchers in Germany have devised a way to build such a processor on an extremely reasonable budget. To achieve HDCP decryption on the fly, the researchers used a standard off the shelf Digilent Atlys Spartan-6 FPGA development board, which comes complete with HDMI input/output ports for easy access to the video stream in question. While not as cheap as this HDCP workaround we covered a few years ago, their solution should prove to be far more flexible than hard wiring an HDMI cable to your television’s mainboard.

The team claims that while their man-in-the-middle attack is effective and undetectable, it will be of little practical use to pirates. While we are aware that HDMI data streams generate a ton of data, this sort of talking in absolutes makes us laugh, as it often seems to backfire in the long run.

[via Tom’s Hardware]

Building A Digital Camera From Scratch

November 28, 2011 by Brian Benchoff 25 Comments

Sure, [Stan] could have bought a nice full-frame DSLR like a Canon 5D or a Nikon D3, but where’s the fun in that when he could build his own digital camera? The build isn’t done yet, but [Stan] did manage to take a few sample pics.

The 14 Megapixel sensor [Stan] found was originally used for benchtop applications. There isn’t any reason it can’t be used for photography, so all that needed to be done was design a camera around this sensor.

[Stan] built his hardware around a DSP, an FPGA and a pair of ADCs, an amazing piece of engineering. Of course building a full-frame digital camera has as much to do with mechanics as electronics, so [Stan] used a 60mm cage system and a 3d-printed nylon enclosure.

Of course, [Stan]’s camera doesn’t look much like and off-the-shelf DSLR. There’s a reason for this; the sensor in the camera has a rolling shutter, much like the last few iPhones instead of a focal plane shutter. Not a bad piece of work, we only wish there were more build pics.