LVDS On An FPGA Could Make It Possible To Reuse Laptops LCDs And The Like

October 3, 2012 by Mike Szczys 41 Comments

Search around the Internet and you’ll find a landfill of forum threads asking how to drive the LCD screen from a dead laptop. The answer is always that there is just no way to do it. That’s because most of them use a Low-Voltage Differential Signalling protocol that just isn’t available through the hardware used in hobby projects. But the appearance of this board could signal that things are about to change. We don’t want to get your hopes up too much. This isn’t an open source project, but it is a piece of hardware that can make LVDS available for the 8, 16, and 32-bit microcontrollers you’re used to working with.

It’s a derivative of a project [Thomas Jespersen] worked on for a customer. It uses an FPGA to implement the LVDS standard used by high-pixel-count LCD displays. It contains enough memory for a full frame-buffer, and includes a Motorola-8080 communication standard. [Thomas] gives a full description of how the setup works in the video after the break. Demonstrations start about 7:30 into the video with an STM32 F4 Discovery board driving the display.

Continue reading “LVDS On An FPGA Could Make It Possible To Reuse Laptops LCDs And The Like” →

Homebrew FPGAs

September 20, 2012 by Brian Benchoff 25 Comments

Homebrew CPUs made out of logic chips are nothing new, but a homebrew FPGA is another matter entirely. [Joshua] sent in a project he whipped up where he made a single logic cell FPGA.

Despite how complicated and intimidating they are in practice, FPGAs are really very simple. They’re made of thousands of logic blocks capable of transmuting into AND, OR, NAND, and XOR logic gates. These logic blocks are all tied together, and with a somewhat complex hardware design language are capable of becoming a CPU, a micocontroller, or even a video card. Basically, programming a microcontroller tells a chip what to do, while programming an FPGA tells the chip what to be.

To build his single logic block FPGA, [Joshua] used a four-bit multiplexer to hard wire a truth table out of a 74HC174 D-type flip-flop. A bit of Arduino code changes the state of the pins connected to the multiplexer allows for any combination of TRUE and FALSE to be calculated for AND, NAND or XOR logic functions.

Yes, it’s only a single logic block for an FPGA, and if this build were expanded to even a few hundred cells it would be gargantuan. Still, there’s no better way to learn the ins and outs of abstract hardware, so we’ll gladly tip our hat to [Joshua] and his homebrew FPGA.

Using An Undocumented Display With An FPGA

September 19, 2012 by Brian Benchoff 11 Comments

When [Mike] ran across a display on Deal Extreme with 8 seven-segment displays, 8 red/green LEDs, and 8 buttons, he knew it would find a good home in a future project. There was only one problem, though: except for an Arduino library, there was absolutely no documentation available for this display. Wanting to use this display with an FPGA board, [Mike] decided against bit-banging a protocol and ported the C++ code into a hardware implementation.

This Deal Extreme display, the TM1638, features enough seven-segment displays, LEDs and buttons to build something really cool, and surprisingly isn’t terribly hard to interface with a microcontroller. The TM1638 library communicates with the outside world via only three pins and a simple serial connection.

After figuring out what commands are sent to make the display turn LEDs on or off, [Mike] wrote a hardware implementation for his Digilent Nexys2 and Digilent Basys2. Now the display operates on an FPGA just like it does with an Arduino, and is a great tool for debugging HDL code for [Mike]’s FPGA.

Full-color Video On A Spinning POV Display

September 11, 2012 by Mike Szczys 30 Comments

Watching Big Buck Bunny on a spinning POV display is pretty impressive. Sure, the circular display area cuts off some of the picture, but otherwise it looks fantastic. This POV display is based on a Gumstix board. It runs embedded Linux which makes video playback rather easy. But translating each frame to the round display is another story.

The device is the result of a course project at Telecom ParisTech. [Félix], [Sylvain], and [Jérémy] used an FPGA to do the pixel mapping. This uses an encoder wheel (rather than a traditional hall effect sensor) to ascertain the blade’s position. The sensor that monitors the disc sends quadrature encoded pulses which result in 10-bit position data. The FPGA uses that data to calculate where each LED falls in its arc, then looks up the pixel color for that position. It’s not the largest POV display we’ve seen, but it certainly has the very best RGB resolution by far.

Continue reading “Full-color Video On A Spinning POV Display” →

Building A Classic Coin-op Game In An FPGA

September 5, 2012 by Mike Szczys 17 Comments

This game of Bomb Jack is the same as the original arcade version. The difference is that this hardware was built in an FPGA using schematics found on the Internet.

We’re a little shocked by the complexity of such a project. We’ve been impressed before by the use of FPGAs to implement classic CRT vector graphics. But that project used a library that had already implemented the original game. For this effort, [Alex] wanted to find a game that hadn’t ever been translated to an FPGA, and used stock parts. Bomb Jack is a 1984 platformer which ran on a Z80 processor, AY-3-8192 sound generators, and common TTL logic chips. This meant he didn’t have to write the cores himself, but rather use already existing versions of the chips and code together the hardware.

You can read about his experience at the page linked at the top, or just jump after the break to see video of the final project. You can see the monitor is on its side, and the game sounds great and runs flawlessly.

Continue reading “Building A Classic Coin-op Game In An FPGA” →

Moving An FPGA Project From VGA To DVI-D

August 3, 2012 by Eric Evenchick 23 Comments

It’s fairly easy to create VGA with an FPGA using a simple R/2R DAC. As [Mike] points out, this requires a lot of IO pins, and many development boards only support 8 bit VGA. Analog VGA is being replaced with DVI-D and HDMI on many devices nowadays, so it would be nice to port projects from VGA to DVI-D.

To address this, he’s come up with a simple DVI-D implementation in VHDL. The result converts RGB and sync data for VGA into DIV-D. Since DVI-D and HDMI both use the same signals for video, this can be connected to either input on a monitor or TV.

This implementation is shown displaying a test pattern on the Pipistrello development board, which features a Spartan 6 LX45 FPGA, but the project was written to be portable to other vendor’s FPGAs. With the right connector and a fast enough clock speed, this project should help move a project from 8 bit VGA to glorious 32 bit color.

MSP430 Gaming Shield Based On The Gameduino

July 31, 2012 by Mike Szczys 18 Comments

Get your 8-bit gaming fix with this gaming shield for the TI Launchpad. It’s called the Launchpad GamingPack and was developed as part of TI’s 2012 Intern Design Contest. The team had just six weeks to complete the project.

The video after the break starts off with some fast-motion PCB layout. It is followed by footage of the board being populated, then anchored with graphics testing and some game play demonstrations. It looks like a real blast! NES controller ports were included on the board, and the device puts out 400×300 VGA, as well as audio.

As with the Gameduino, the hard work is done by the FPGA at the center of this board. It handles all of the VGA timing work, using what looks like 3-bit color. It is also responsible for generating the audio and monitoring the inputs. Since the team was under a time crunch the shield also includes a 10-pin header on the underside which was added for easy connection with a logic analyzer.

Continue reading “MSP430 Gaming Shield Based On The Gameduino” →