SDRAM Controller For Low-end FPGAs

October 11, 2013 by Mathieu Stephan 25 Comments

There are very few ‘recent’ FPGAs out there that can be easily soldered. Due to their important number of IOs, they usually come in Ball Grid Array (BGA) packages. The Xilinx Spartan 6 LX9, a TQFP144 FPGA (having pins with a 0.5mm pitch) is one of the few exceptions that can be used to make low end development boards. However, it doesn’t have a lot of logic and memory resources or an on-chip Memory Control Block implemented in the silicon. Therefore, [Michael] designed an SDRAM controller with a small footprint for it.

Writing an SDRAM controller from scratch isn’t for the fainthearted – first of all you really have to know how SDRAM works (RAS, CAS, precharges, refresh cycles), and because of the high speed and accurate timing required you also have to learn some of the finer points of FPGA off-chip interfacing. In addition, most publicly available open cores are very complex – for example just the RTL core of the sdr_ctrl controller on opencores.org adds up to over 2,700 lines of Verilog. Even if it is not an accurate comparison metric, [Michael]’s controller is only 500 lines long.

Building An Audio Box Out Of Thrown Away Boards

August 24, 2013 by Mathieu Stephan 9 Comments

The last time [Mark] was at the scrap yard, he managed to find the analogue input and output cards of an old Akai DR8 studio hard drive recorder. These cards offered great possibilities (8 ADC inputs, 12 DAC outputs) so he repaired them and made a whole audio system out of them.

The repair only involved changing a couple of low dropout regulators. Afterwards, [Mark] interfaced one of his CPLD development boards so he could produce some sine waves and digitize signals generated from a PC based audio test unit. He then made the frame shown in the picture above and switched to an Altera Cyclone IV FPGA. To complete his system, he designed a small board to attach a VGA screen, and another to use the nRF24L01 wireless module.

Inside the FPGA, [Mark] used a NIOS II soft core processor to orchestrate the complete system and display a nice user interface. He even made another system with an USB host plug to connect MIDI enabled peripherals, allowing him to wirelessly control his creation.

Making Vector Arcade Games With An FPGA

August 10, 2013 by Brian Benchoff 11 Comments

While we’re sure most Hackaday readers were raised by arcade games featuring sprites, pixels, and other shiny brightly colored squares, this was not always so. Many classic arcade games – Lunar Lander, Gravitar, and Asteroids in particular – used vector displays. Instead of drawing individual pixels, these games functioned more like an oscilloscope, drawing lines. When [Todd] and [Andrew] got their hands on a monitor from an old Asteroids cabinet, they knew what they had to do: build their own vector arcade game.

The guys made their own DAC and Amplifier board that plugs right in to a Nexys2 FPGA dev board. This was after they tested out some 3D drawing code with a gnarly handmade R2R DAC they used to draw and rotate a cube on an oscilloscope screen.

Not only did the guys build a vector video card, they also connected the FPGA’s VGA out to a monochrome monitor for an in-game HUD. Awesome work that blows away anything available in the golden days of vector arcade games. It’s a beautiful piece of engineering that certainly deserves its own cabinet.

Video of the game available below.

Continue reading “Making Vector Arcade Games With An FPGA” →

Giving The VirtualBoy A VGA Out

June 17, 2013 by Brian Benchoff 19 Comments

Nintendo’s VirtualBoy – the odd console-inside-a-pair-of-goggles and arguable ancestor of Nintendo’s 3DS – was a marvelous piece of technology for its time. In a small tabletop unit, you were able to play true 3D video games at an impressive 384 x 224 pixel resolution. Of course the VirtualBoy was a complete failure, but that doesn’t mean hardware tinkerers are leaving this wonderful system to video game collectors. [furrtek] has been playing around with his VirtualBoy and managed to add VGA out.

As a 3D system with two displays, any sort of video out was rightfully ignored by the VirtualBoy system designers. Still, [furrtek] wanted some sort of video out on his system, so he began poking around with a small FPGA board to generate some VGA signals.

The two displays inside the VirtualBoy aren’t your normal LCD display – as seen in this iFixit teardown. they’re really two linear LED arrays that generate a single line of 244 pixels, with mirrors scanning the line in the in the Y axis. These LED arrays are controlled by the VirtualBoy CPU through a series of shift registers, and by carefully tapping the lines of each LED array, [furrtek] was able to copy all the image data into the RAM of an FPGA.

After stuffing an XESS XULA-200 FPGA board inside the case of his VirtualBoy, [furrtek] wired up a few resistors for a DAC and installed a VGA out port on the underside of his console. Everything worked the first time he powered it up, and he began playing his VirtualBoy on his big screen TV.

Because [furrtek] is only reading one of the VirtualBoy’s displays, all the 3D data – and the main feature of the VirtualBoy – is lost when it’s displayed on a TV. 3D TVs do exist, though, and we’d love to see an improved version of this that captures data from both of the VirtualBoy displays.

You can see [furrtek]’s video of his mod in action below.

Continue reading “Giving The VirtualBoy A VGA Out” →

Camera-based Touchscreen Input Via An FPGA

May 20, 2013 by Mike Szczys 7 Comments

piano-hero-uses-camera-based-touch-input

[Chonggang Li] wrote in to share a link to the final project he and [Ran Hu] built for their embedded systems class. It’s called Piano Hero and uses an FPGA to implement a camera-based touch screen system.

All of the hardware used in the project is shown above. The monitor acts as the keyboard, using an image produced by the FPGA board to mark the locations of each virtual key. It uses a regular VGA monitor so they needed to find some way to monitor touch inputs. The solution uses a camera mounted above the screen at an obtuse angle. That is to say, the screen is tilted back just a bit which allows the images on it to be seen by the camera. The FPGA board processes the incoming image, registering a key press when your finger passes between the monitor and the camera. This technique limits the input to just a single row of keys.

This should be much simpler than using a CCD scanner sensor, but that one can track two-dimensions of touch input.

Continue reading “Camera-based Touchscreen Input Via An FPGA” →

Hackaday Links: Sunday, May 19th, 2013

May 19, 2013 by Mike Szczys 32 Comments

Laser cutter owners may find this online box design tool which [Jon] built quite useful. It’s got a few more joint options than the Inkscape box design add-on does.

Apparently the US Navy has the ability to bring down drones in a flaming pile of laser-caused death. [Thanks Joshua]

[Michail] has been working on a transistor-based full adder. He’s posted a Spice simulation if you want to learn about the design.

Turn your crystal clear LED bodies into diffuse ones using a wooden dowel, power drill, and sandpaper. The results look better than what we’ve accomplished by hand. [Thanks Vinnie]

Play your favorite Atari Jaguar games on an FPGA thanks to the work [Gregory Estrade] did to get it running on a Stratix-II board. You can pick up the VHDL and support tools in his repo. If you’re just curious you can watch his demo vid.

Members of Open Space Aarhus — a hackerspace in Risskov, Denmark — have been playing around with a bunch of old server fans. They made a skirtless hovercraft by taping them together and letting them rip. Too bad it can’t carry its own power supply

Here’s another final project from that bountiful Cornell embedded systems class. This team of students made a maze game that forms the maze by capturing walls drawn on a white board.

And finally, here’s a unique chess board you can build by raiding your parts bin. [Tetris Monkey] made the board from the LCD screen of a broken monitor. The playing pieces are salvaged electronics (like big capacitors) against corroded hardware (like nuts and bolts). We think it came out just great!

Homebrew GPS Gets ±1 Meter Resolution With A Raspberry Pi

May 17, 2013 by Brian Benchoff 50 Comments

GPS

We’ve been following the work of [Andrew Holme] and his homebrew GPS receiver for a while now. A few years ago, [Andrew] built a four-channel GPS receiver from scratch, but apparently that wasn’t enough for him. He expanded his build last year to track up to eight satellites, and this month added a Raspberry Pi for a 12-channel, battery-powered homebrew GPS receiver that has an accuracy of about 3 feet.

The Raspi is attached to an FPGA board that handles the local oscillator, real-time events, and tracks satellites automatically. The Pi handles the difficult but not time-critical math through an SPI interface. Because the Pi is attached to the FPGA through an SPI interface, it can also load up the FPGA with even more custom code, potentially turning this 12-channel receiver into a 16- or 18-channel one.

An LCD display attached to the FPGA board shows the current latitude, longitude, and other miscellaneous data like the number of satellites received. With a large Li-ion battery, the entire system can be powered for about 5 hours; an impressively portable GPS system that rivals the best commercial options out there.