FPGA Magic Puts Little Embedded Screens Up On The Big Screen

Old-school handheld gaming platforms have a certain charm, but it’s fair to say that their relatively tiny screens don’t lend themselves to wider viewing. This presented a problem to [uXe] who wanted to display Arduboy games on the big screen, so he took a MyStorm BlackIce FPGA board and created a converter that emulates a SSD1306 OLED display and has a VGA output.

Having proved the viability of the idea, it was ported to a dedicated PCB with onboard ancillaries such as a level shifter for a 5 volt input. In an exciting twist, with a few modifications it’s also emulated a GameBoy screen, allowing full-sized playable games from that platform too. But the power of this hack isn’t relegated to gaming. SSD1306 is just one of a few different common standards for embedded displays. The FPGA work in this project is the blueprint for building a VGA adapter for any number of display replacements. We’d love to see an HD44780 mod of this!

The result as you can see in the video below the break is very much more in the spirit of the OLED than an HD immersive experience. But it does have a very pleasing air of an older arcade machine about it.

Several projects starting on a MyStorm BlackIce board have made it here in the past. Pretty memorable is the BBC Micro clone using one.

Continue reading “FPGA Magic Puts Little Embedded Screens Up On The Big Screen”

Racing The Beam On An ATtiny

For the last thirty or so years, the demoscene community has been stretching what is possible on computer systems with carefully crafted assembly and weird graphical tricks. What’s more impressive is hand-crafted assembly code pushing the boundaries of what is possible using a microcontroller. Especially small microcontrollers. In what is probably the most impressive demo we’ve seen use this particular chip, [AtomicZombie] is bouncing boing balls on an ATtiny85. It’s an impressive bit of assembly work, and the video is some of the most impressive stuff we’ve ever seen on a microcontroller this small.

First, the hardware. This is just about the simplest circuit you can build with an ATtiny85. There’s an ISP header, a VGA port with a few resistors, a 1/8″ audio jack driven by a transistor, and most importantly, a 40MHz crystal. Yes, this ATtiny is running far faster than the official spec allows, but it works.

The firmware for this build is entirely assembly, but surprisingly not that much assembly. It’s even less if you exclude the hundred or so lines of definitions for the Boing balls.

The resulting code spits out VGA at 204×240 resolution and sixty frames per second. These are eight color sprites, with Alpha, and there’s four-channel sound. This is, as far as we’re aware, the limit of what an ATtiny can do, and an excellent example of what you can do if you buckle down and write some really tight assembly.

Continue reading “Racing The Beam On An ATtiny”

FPGA Makes ASCII Video

Human beings like pictures which is probably why there’s the old adage “A picture’s worth a thousand words.” We take computer graphic output for granted now, but even in the earliest days for Teletypes and line printers, there was artwork made from characters ranging from Snoopy to Spock. [Wenting Z] continues the tradition by creating an FPGA that converts VGA video to ASCII art and outputs it via DVI.

The device uses a Xilinx Virtex device and uses about 500 LUT (look up tables) which is not much at all. You can see a video (that includes an overlay of the source video) of the device in action below.

In fact, we think of art like this as a computer phenomenon, but [Flora Stacey] created a butterfly on a typewriter in 1898 and ham radio operators were doing art using paper tape for the last half of the twentieth century. Even before that, In 1865, Alice in Wonderland had a certain passage that was typeset to suggest a mouse’s tail. Perhaps the pinnacle is the famous ASCII version of Star Wars.

This is decidedly less mechanical than some of the other ASCII art projects we’ve seen. If you have a taste for more text art, have a look at some other examples, including a very old advertisement that uses character art.

Continue reading “FPGA Makes ASCII Video”

Hackaday Prize Entry: PaperBack Desktop ePaper Monitor

When we announced the Hackaday Prize with its Best Product category, [PK] polled his wife and co-workers about the idea of making a desktop monitor using 6″ 800×600 ePaper, which he has since built and calls the PaperBack. One such requirement for a monitor is to be able to connect to it using one of the usual desktop methods: VGA, DVI or HDMI. Given his previous experience making his own VGA card for the 2015 prize, he went with that. HDMI is in the works.

But it ended up being more than a desktop monitor. He first made a power and breakout board that a VGA input board would eventually connect to. To test it, he included a socket for plugging in an ESP32. With only one bodge he had the Hackaday logo displayed on the ePaper. He also now had the option of using it as a wireless internet connected display.

Moving on to VGA support, [PK] made a VGA input board using the MST9883 chip, which does the A/D conversion of the VGA RGB graphics signal and also recovers a pixel sampling clock from the HSYNC. His new VGA ePaper monitor has to identify itself to the VGA source, telling it dimensions, resolution and so on. This is called the EDID and was handled by the addition of an Atmel ATmega328 to the board. To finish it off, an LCMXO1200C FPGA does the high-speed conversions with the help of a 4 MBit SRAM framebuffer.

His very first test involved simply displaying the Hackaday logo using the ESP32, but now with the VGA input board he has it displaying Doom. Since it’s using ePaper it has only a 1-second refresh rate but it’s hard to come up with a more awesome way to proved that it works. He can also unplug it at any time and walk away with the latest screenshot intact. See it for yourself in the video below.

Continue reading “Hackaday Prize Entry: PaperBack Desktop ePaper Monitor”

FPGA Rescues Scope From The Dumpster

I’m always on the lookout for a quality addition to my lab that would respect my strict budget. Recently, I’ve found myself pushing the Hertz barrier with every other project I do and hence desperately wanted a high bandwidth scope. Unfortunately, only recently have 70 MHz to 100 MHz become really affordable, whilst a new quad channel oscilloscope in the 500 MHz to 1 GHz range still costs a fortune to acquire. My only option was to find an absolute miracle in the form of an old high bandwidth scope.

It seemed the Gods of Hand Me Down electronics were smiling upon me when I found this dumpster destined HP 54542C. It appeared to be in fairy good shape and was the Top Dog in its day. But something had to be broken right? Sure enough, the screen was clearly faulty and illegible. Want to know how I fixed it? Four letters: FPGA.

Continue reading “FPGA Rescues Scope From The Dumpster”

The Modern Retrocomputer: An Arduino Driven 6845 CRT Controller

[MmmmFloorPie] revived an old project to create the retro mashup of a 6845 CRT controller and a modern Arduino Uno. When it comes to chips, the Motorola 6845 is the great granddaddy of Cathode Ray Tube (CRT) interfaces. It was used in the IBM Monochrome display adapter, the Hercules graphics controller, CGA, Apple II terminal cards, and a host of other microcomputer and terminal systems.

Way back in 1989, [MmmmFloorPie] was a senior in college. His capstone project was a 68000 based computer which could record and playback audio, as well as display waveforms on a CRT. The CRT in question was ordered from a classified add in Popular Science magazine. It was a bare tube, so the heavy cardboard box it shipped in was repurposed as a case.

Fast forward to today, and  [MmmmFloorPie] wanted to power up his old project. The 68000 board was dead, and he wasn’t up to debugging the hundreds of point to point soldered connections. The CRT interface was a separate board including the 6845 and 32 KByte of RAM. It would only take a bit of hacking to bring that up. But what would replace the microprocessor?

Continue reading “The Modern Retrocomputer: An Arduino Driven 6845 CRT Controller”

VGA Without A Microcontroller

One of the most challenging projects you could ever do with an 8-bit microcontroller is generating VGA signals. Sending pixels to a screen requires a lot of bandwidth, and despite thousands of hackers working for decades, generating VGA on an 8-bit microcontroller is rarely as good as a low-end video card from twenty years ago.

Instead of futzing around with microcontrollers, [Marcel] had a better idea: why not skip the microcontroller entirely? He’s generating VGA frames from standard logic chips and big ‘ol EEPROMs. It works, and it looks good, too.

VGA signals are just lines and frames, with RGB pixel values stuffed in between horizontal sync pulses, and frames stuffed between vertical sync pulses. If you already know what you want to display, all you have to do is pump the right bits out through a VGA connector fast enough. [Marcel] is doing this by saving images on two parallel EEPROMs, sending the output through a buffer, through a simple resistor DAC, and out through a VGA connector. The timing is handled by a few 74-series four-bit counters, and the clock is a standard 25.175 MHz crystal.

There’s not much to this build, and the entire circuit was assembled on a breadboard. Still, with the clever application of Python to generate the contents of the ROM, [Marcel] was able to build something that displays eight separate images without using a microcontroller.