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.

 

PIC Retrocomputer Boasts VGA, PS/2 Keyboard

You might think that our community would always strive to be at the cutting edge of computing and use only the latest and fastest hardware, except for the steady stream of retrocomputing projects that appear. These minimalist platforms hark back to the first and second generation of accessible microcomputers, often with text displays if they have a display at all, and a simple keyboard interface to a language interpreter.

Often these machines strive to use the hardware of the day, and are covered with 74 logic chips and 8-bit processors in 40-pin dual-in-line packages, but there are projects that implement retrocomputers on more modern hardware. An example is [Sebastian]’s machine based upon a couple of PIC microcontrollers, one of which is an application processor with a PS/2 keyboard interface, and the other of which handles a VGA display interface. The application it runs calculates whether a 4-digit number is a prime and displays its results.

His write-up gives a fascinating overview of the challenges he found in creating a reliable VGA output from such limited hardware, and how he solved them. Though this one-sentence description makes a ton of work sound easy, horizontal sync pulses are generated as hardware PWM, and pixel data is streamed from the SPI bus. The VGA resolution is 640×480, upon which he could initially place a 10×10 block of text. Later optimizations extend it to 14×14.

Sometimes it’s not the power of the hardware but the challenge of making it perform the impossible that provides the attraction in a project, and on this front [Sebastian]’s retrocomputer certainly delivers. We’ve featured many other retrocomputers before here, some of which follow [Sebastian]’s example using modern silicon throughout, while others mix-and-match old and new.

Does This Demo Remind You of Mario Kart? It Should!

Here’s a slick-looking VGA demo written in assembly by [Yianni Kostaris]; it’s VGA output from an otherwise stock ATmega2560 at 16MHz with no external chips involved. If you’re getting some Super Mario Kart vibes from how it looks, there’s a good reason for that. The demo implements a form of the Super Nintendo’s Mode 7 graphics, which allowed for a background to be efficiently texture-mapped, rotated, and scaled for a 3D effect. It was used in racing games (such as Super Mario Kart) but also in many others. A video of the demo is embedded below.

[Yianni] posted the original demo a year earlier, but just recently added detailed technical information on how it was all accomplished. The AVR outputs VGA signals directly, resulting in 100×120 resolution with 256 colors, zipping along at 60 fps. The AVR itself is not modified or overclocked in any way — it runs at an entirely normal 16MHz and spends 93% of its time handling interrupts. Despite sharing details for how this is done, [Yianni] hasn’t released any code, but told us this demo is an offshoot from another project that is still in progress. It’s worth staying tuned because it’s clear [Yianni] knows his stuff.

Continue reading “Does This Demo Remind You of Mario Kart? It Should!”

FPGA Computer Covers A to Z

[F4HDK] calls his new computer A2Z because he built everything from scratch (literally, from A to Z). Well, strictly speaking, he did start with an FPGA, but you have to have some foundation. The core CPU is a 16-bit RISC processor with a 24-bit address bus and a 128-word cache. The computer sports 2 megabytes of RAM, a boot ROM, a VGA port and keyboard, and some other useful I/O. The CPU development uses Verilog.

Software-wise, the computer has a simple operating system, a filesystem, and basic programs like a text editor and an image viewer. Development software includes an assembler and a compiler for a BASIC-like language that resides on the PC. You can also run an emulator to experiment with A2Z without hardware. You can see a “car game” running on A2Z in the video below. You can also see videos of some other applications.

Continue reading “FPGA Computer Covers A to Z”