Game Boy Recreated In Verilog

March 23, 2019 by Lewin Day 8 Comments

With the wide availability of Raspberry Pi hardware and pre-baked Linux distros with emulators ready to go, making a retro handheld is easier than ever. Emulation isn’t the only way to go about playing old games however. [Wenting Zhang] decided to instead recreate the Nintendo Game Boy in Verilog, and has documented the effort.

The project runs on a Spartan 6 FPGA. [Wenting] first developed the hardware to use a DualShock controller for input, and output video to a regular LCD monitor. However, work is now underway to produce a handheld VerilogBoy. This will feature a 320×320 LCD screen, with pixels being quadrupled from the original Game Boy 160×144 resolution, with some pixels to spare. [Wenting] is also looking at porting the code to some Pano Logic units, which we’ve discussed before. The thin clients pack FPGA hardware and lots of IO ports that make them perfect for such a project.

Code is available on Github for the curious tinkerers out there. While there are easier ways to play old handheld games, the amount of learning value of such a project should not be underestimated. We’ve seen FPGAs used for other Nintendo hijinx, too – like this NES cart that packs some serious muscle. Video after the break.

Continue reading “Game Boy Recreated In Verilog” →

An FPGA Drives This Antique LCD Screen

March 20, 2019 by Lewin Day 7 Comments

If you’re reading this article on a desktop or laptop computer, you’re probably staring at millions of pixels on a TFT LCD display. TFT became a dominant technology due to its picture quality and fast response times, but it’s not the only way to build an LCD. There are cheaper technologies, such as STN and its color variant, CSTN. They’re rarely used nowadays, but [Wenting Zhang] had one lying around and wanted to take a crack at driving it.

Still scenes aren’t bad, but motion blur is readily apparent on any moving content.

The screen in question came courtesy of a 20th century laptop. It’s a Hitachi SX21V001-Z4, with a resolution of 640×480 pixels. Driver boards for CSTN screens were once readily available, however now such things are difficult to come by.

[Wenting] instead grabbed an FPGA and got to work. Driving displays can be taxing for small microcontrollers, so an FPGA is always a great choice when working on such projects. They’re easily capable of generating whatever weird and wacky signals are required, and can generate many such signals in parallel without breaking a sweat.

[Wenting] successfully got the screen up and running, and hooked up to a VGA input. Image quality is surprisingly passable for still images, though things absolutely go to pieces when motion is introduced. [Wenting]’s demo shows off the screen playing Breath of the Wild, and it’s a great showcase of how far technology has come since the mid-90s.

Driving strange LCDs is a hacker rite of passage, and we see plenty of efforts around these parts. Video after the break.

Continue reading “An FPGA Drives This Antique LCD Screen” →

FPGA NES Looks Sharp On Perfboard

March 18, 2019 by Lewin Day 4 Comments

FPGAs are wonderful things, packed with logic cells that can be reconfigured as your heart desires. They excel at signal processing, anything requiring speed, and recreating vintage hardware. In that vein, [Jon Thomasson] decided to bring back the original Nintendo Entertainment System, in perfboard form.

The build uses a Spartan 6 from Xilinx, which [Jon] uses in the form of his own development board design. The NES core is courtesy of code by [Brian Bennett], sourced from Github. Games are loaded from an SD card by a Parallax Propeller, which passes the data to the FPGA over a serial connection. Display is on a sharp 800×480 LCD, with the 4:3 video output of the NES being displayed in a pillarboxed fashion.

The project is assembled on perfboard, with a pleasing handheld formfactor. Control is via tactile pushbuttons in the classic NES layout. Current draw is approximately 400 mA, giving a runtime of around 5 hours when running off four AA batteries.

We’ve seen the venerable NES implemented on FPGA platforms before. As development boards get cheaper and devices get more capable, expect to see ever more complex systems being implemented. Video after the break.

Continue reading “FPGA NES Looks Sharp On Perfboard” →

An HDMI Input For A Laptop Screen, Minus Laptop

March 14, 2019 by Bryan Cockfield 11 Comments

The lack of HDMI inputs on almost all laptops is a huge drawback for anyone who wants to easily play a video game on the road, for example. As to why no manufacturers offer this piece of convenience when we all have easy access to a working screen of this size, perhaps no one can say. On the other hand, if you want to ditch the rest of the computer, you can make use of the laptop screen for whatever you want.

This project from [Avner] comes to us in a few parts. In the first section, the teardown of the laptop begins and a datasheet for the screen is discovered, which allows [Avner] to prepare an FPGA to drive the screen. The second part involves building an HDMI sink, which is a device which decodes the signal from an HDMI source into its constituent parts so it can be sent to the FPGA. The final section of the project involves actually sending a video to this impressive collection of hardware in order to get a video to appear on the old laptop screen.

This build is worth checking out if you’ve ever dealt with anything involving digital video. It goes into great depth on a lot of the technical details involving HDMI, video devices, and hardware timing issues. This is a great build and, even though we’ve seen similar projects, definitely worth diving into if you have some time on your hands and a spare laptop screen.

Component Video For The Commodore 64

March 10, 2019 by Brian Benchoff 36 Comments

Of all the retro systems, the Commodore 64 had the best video system. The VIC-II chip in the C64 was the best example of why Commodore was the best, but in terms of video output, the C64 was still a consumer device: the only output was S-video, or composite video, or something like it. The professional stuff uses YPbPr, an RGB video signal that separates the red, green, and blue colors. On a modern LCD, the difference between composite and YPbPr is noticeable, and if you’re going to run your C64 on the big screen, it would be very helpful to use a professional video standard.

In an effort to bring the C64 into the future, [c0pperdragon] created an FPGA-based modification for the VIC-II chip. The end result is getting YPbPr signals directly from the computer, and outputting it to a TV in glorious 480p.

Inside the Commodore 64, the VIC-II creates the chrominance signal in a way that is impossible to convert it back to any form of RGB. The solution to get RGB out of this information is to listen in to 22 pins of the VIC-II to determine what signals it intends to generate. This is done with a smallish Altera FPGA connected to the VIC-II through a ribbon cable. On the FPGA, the luminescence and all the color information is generated, then converted into true YPbPr. For the complete mod, the RF modulator is removed, and the original A/V jack is still functional. This is effectively a very in-depth mod that rids the C64 of the TV connector and channel selector (that no one uses anymore) and replaces it with a professional-grade video output.

When it comes to C64 mods, we thought we’ve seen it all. We’ve seen C64s resurrected from the dead, and we’ve seen drop-in replacements for the SID that still don’t have working filters oh my god. This is on another level. This is using FPGAs to drag the C64 into the modern era, and if you don’t care about the rusting RF box, it’s a reversible mod.

FPGA Brings Arduboy To The Game Boy Advance

February 21, 2019 by Tom Nardi 8 Comments

Hackaday readers are perhaps familiar with the Arduboy, an open source handheld gaming system that aims to combine the ease of Arduino development with the seething nostalgia the Internet has towards the original Nintendo Game Boy. While not quite the same as getting one of your games published for a “real” system, the open source nature of the Arduboy platform allows an individual to develop a game playable on a commercially manufactured device.

While the Arduboy hardware itself is actually quite slick, that hasn’t stopped people from trying to bring its games to other pieces of hardware. Now thanks to the efforts of [uXe], the Game Boy Advance is well on its way to becoming Arduboy compatible, in a way bringing the whole project full circle. Assuming this gadget becomes a commercial device (it sounds like that’s still up in the air), Arduboy developers will be able to proudly play their creations on the final and objectively best entry into the Game Boy line.

Getting to this point has been something of an adventure, as documented in a thread from the Arduboy forums. Members of the community wondered what it would take to get Arduboy games running on a real Game Boy, but pretty quickly it was decided that the original beige brick model wasn’t quite up to the task. Eventually its far more capable successor the Game Boy Advance became the development target, and different approaches were considered for getting existing games running on the platform.

While there were some interesting ideas, such as using the GBA’s link port to “feed” the system games over SPI, in the end [uXe] decided to look into creating an FPGA cartridge that would actually run the Arduboy games. In this scenario, the GBA itself is basically just being used as an interface between the FPGA and the human player. In addition to these low-level hardware considerations, there was considerable discussion about the more practical aspects of bringing the games to the new hardware, such as how to best scale the Arduboy’s 128 x 64 output to the GBA’s 240 × 160 screen.

As demonstrated in the videos after the break, [uXe] now as all the elements for playing Arduboy games on the GBA in place, including the ability to disable full screen scaling by using the shoulder buttons. Now he just needs to shrink the hardware down to the point it will fit inside of a standard GBA cartridge. Beyond that, who knows? Perhaps the appeal of being able to run Arduboy games on a real Game Boy is enough to warrant turning this hack into a new commercial product.

Thanks to a hardware swap we’ve seen Arduboy games played on the Dreamcast VMU, and [uXe] himself previously grafted Arduboy-compatible hardware into an original Game Boy, but being able to play these games on an unmodified Game Boy Advance obviously has its own appeal. At the very least, it will be a bit more ergonomic than using a hacked classroom gadget.

Continue reading “FPGA Brings Arduboy To The Game Boy Advance” →

FPGA Makes Digital Analog Computer

February 14, 2019 by Al Williams 6 Comments

When you think of analog computing, it’s possible you don’t typically think of FPGAs. Sure, a few FPGAs will have specialized analog blocks, but usually they are digital devices. [Bruce Land] — a name well-known to Hackaday — has a post about building a digital differential analyzer using an FPGA and it is essentially an analog computer simulated on the digital fabric of an FPGA.

Whereas traditional analog computers use operational amplifiers to do mathematical integration, on the FPGA [Land] uses digital summers The devices simulate a system of differential equations, which can be nonlinear.

Continue reading “FPGA Makes Digital Analog Computer” →