TRS-80 Gains Multiple Monitor Support, And High-Resolution Graphics

To call [Glen Kleinschmidt] a vintage computing enthusiast would be an understatement. Who else would add the ability to control and address multiple VGA monitors to a rack-mounted TRS-80 Model 1? Multiple 64-color 640×480 monitors might not be considered particularly amazing by today’s standards, but for 70s-era computing, it’s a different story.

Drawing this sin(x)/x ripple surface can be done in only 17 lines of BASIC.

How does a TRS-80 even manage to output anything useful to these monitors? [Glen] wrote his own low-level driver in machine code to handle that. The driver even has useful routines that are callable from within BASIC, meaning that programs written on the TRS-80 are granted powerful drawing abilities. Oh, and did we mention that the VGA graphics cards themselves were designed and made by [Glen]?

Interested in making your own? [Glen] provides all the resources you’ll need to re-create his work, including machine code drivers and demonstration BASIC programs as downloadable audio files, just as they would have been on original cassette tapes.

Watch things in action in the videos embedded below. The first draws a Land Rover, and the second plots a simple Moiré pattern star. Not bad for 70s-era hardware and 74xx logic!

Continue reading “TRS-80 Gains Multiple Monitor Support, And High-Resolution Graphics”

Z80 Single-Board Computer Looks Like It Could Have Been A Killer Product

Most retrocomputer builds seem to focus on either restoring old machines or rebuilding them from scratch. Either way, the goal is to get as close as possible to the original machine, and while we certainly respect those builds, there are other ways to celebrate the computers of yesterday, as this Z80 single-board computer nicely demonstrates.

[Ivan Farafontov]’s SBC is sort of a “Z80 that never was” build, one that would almost have been possible back in the heyday of 8-bit computing, and would have made quite a splash if it had. Most of the peripheral chips are from Zilog and would have been found in many of the Z80 machines of the day, like the TRS-80 and ZX Spectrum. Where it goes off the old-school path is with the video section, which uses an Atmel CPLD chip and a dual-port RAM to drive a VGA monitor. It still looks the part, though, with a 256×192 pixel, 16-color display. The compact video section helps keep the overall footprint of this machine pretty small, at least by the standards of the old machines. The machine is barely larger than its custom keyboard, which is populated with mechanical switches and really nice-looking custom keycaps, and everything fits into a 3D-printed case.

The demo that starts at the 4:30 mark of the video below will be a nostalgia storm for a lot of readers, starting as it does with a version of Boulder Dash that [Ivan] wrote from scratch, along with the tile editor he used to create the sprites for the game. All the design files and code are available if you want to build your own, of course. We recently featured another Z80 that never was, but [Ivan]’s machine really makes a statement with its compact size and its capabilities.

Continue reading “Z80 Single-Board Computer Looks Like It Could Have Been A Killer Product”

Have You Heard Of MCGA?

In the world of PC graphics, the early standards followed the various video cards of the day. There was MDA, familiar through the original text-based DOS prompt, CGA, then EGA, and the non-IBM Hercules along the way. Finally in 1987 IBM produced the VGA, or Video Graphics Array standard for their PS/2 line of computers, which became the bedrock on which all subsequent PC graphics cards, even those with digital outputs, have been built. It’s interesting then to read an account from [Dave Farquhar] of the other now-forgotten video standard that made its debut with the PS/2, MCGA, or Multicolor Graphics Array. This was intended as an entry-level graphics system to compete with the more multimedia-oriented home computers of the day such as the Commodore Amiga and Atari ST.

Offering 320×200 graphics at 256 colors but only two colors at 640×480 it’s difficult to see how it could have been a viable competitor to the Amiga’s 4096-color HAM mode, but it did offer the ability to drive an RGB monitor through its VGA-like socket. The story goes that IBM intended it to provide an upgrade incentive for PS/2 customers to buy a more powerful model with VGA, but in the event a host of third-party VGA-compatible cards emerged and allowed more traditional ISA computers from third parties to retain a competitive edge and eventually sideline the PS/2 line entirely.

We called time on VGA back in 2016, and it’s fair to say that it’s disappeared from PC hardware since then even if much of its technologies still lurk within. It’s pleasing to see though that it remains a stalwart of hacked-together display interfaces, with efforts such as this 7400-based VGA card continuing to impress us.

Retro Serial Terminal Uses Modern Chips To Get CP/M Machine Talking

The hobbyists of the early days of the home computer era worked wonders with the comparatively primitive chips of the day, and what couldn’t be accomplished with a Z80 or a 6502 was often relegated to complex designs based on logic chips and discrete components. One wonders what these hackers could have accomplished with the modern components we take for granted.

Perhaps it would be something like this minimal serial terminal for the current crop of homebrew retrocomputers. The board is by [Augusto Baffa] and is used in his Baffa-2 homebrew microcomputer, an RC2014-esque Z80 machine that runs CP/M. This terminal board is one of many peripheral boards that plug into the Baffa-2’s backplane, but it’s one of the few that seems to have taken the shortcut of using modern microcontrollers to get its job done. The board sports a pair of ATmega328s; one handles serial communication with the Baffa-2 backplane, while the other takes care of running the VGA interface. The card also has a PS/2 keyboard interface, and supports VT-100 ANSI escapes. The video below shows it in action with a 17″ LCD monitor in the old 4:3 aspect ratio.

We like the way this terminal card gets the job done simply and easily, and we really like the look of the Baffa-2 itself. We also spied an IMSAI 8080 and an Altair 8800 in the background of the video. We’d love to know more about those.

Continue reading “Retro Serial Terminal Uses Modern Chips To Get CP/M Machine Talking”

Game Boy Becomes Super Game Boy With A Pair Of Pis

For the Nintendo aficionados of the 90s, the Super Game Boy was a must-have cartridge for the Super Nintendo which allowed gamers to play Game Boy games on your TV. Not only did it allow four-color dot-matrix gaming on the big screen, but it let you play those favorite Game Boy titles without spending a fortune on AA batteries. While later handhelds like the PSP or even Nintendo Switch are able to output video directly to TVs without issue, the original Game Boy needed processing help from an SNES or, as [Andy West] shows us, it can also get that help from a modern microcontroller.

Testing the design before installing it in the NES case.

The extra processing power in this case comes from a Raspberry Pi Pico which is small enough to easily fit inside of a donor NES case and also powerful enough to handle the VGA directly. For video data input, the Pico is connected to the video pins on the Game Boy’s main board through a level shifter. The main board is also connected to a second Pico which handles the controller input from an NES controller. Some fancy conversion needed to be done at this point because although the controller layouts are very similar, they are handles by the respective consoles completely differently.

With all of the technical work largely out of the way, [Andy] was able to put the finishing touches on the build. These included making sure the power buttons, status LEDs, and reset button all functioned, and restoring the NES case complete with some custom “Game Guy” graphics to match the original design of the Game Boy. We commend the use of original Game Boy hardware in this build as well, which even made it possible for [Andy] and his wife to play a head-to-head game of Dr. Mario through a link cable with another Game Boy. If you’re looking for a simpler way of playing on original hardware without burning a hole in your wallet buying AA batteries, take a look at this Game Boy restoration which uses a Lithium battery instead.

Continue reading “Game Boy Becomes Super Game Boy With A Pair Of Pis”

Picture of a monitor with a fake "ransomware" banner on it, and a PC with the ESP32 VGA devboard mounted into it in the foreground

ESP32 Pretends To Be GPU; Gives You A Ransomware Scare

Sometimes a piece of hardware meets a prank idea, and that’s how the fun Hackaday articles are born. [AnotherMaker] shows us some harmless entertainment at the expense of an IT enthusiast in your life – programming an ESP32-powered devboard with a VGA output to show an ever-feared “all your files are encrypted” screen on a monitor connected to it. The ASCII text in its 8-bit glory helps sell this prank, making it look exactly like a BIOS-hijacking piece of malware it claims to be; akin to UIs of the past that skilled hackers would whip up in x86 assembly. The devboard’s integration into a PCI card backplate is a cherry on top, a way to seamlessly integrate this into a PC case, making it look not particularly different from an old graphics card. In such a configuration, we don’t doubt that this would be a head-scratcher to a certain kind of an IT department worker.

If you already have someone in mind as a target for this prank, you’re in luck, since [AnotherMaker] has shared his source code, too, and all you need is a ESP32 with a VGA port set up. You can get the same devboard, or you can even solder it all together with an ESP32 breakout and resistors, if you’re on a time or money budget, since the schematics for the LilyGO devboard are public. Not all devboards gets such a fun application, but it’s always fun to see when someone thinks of one – a perfect prank scenario that calls for a very specific devboard.

Wondering how it’s even possible to output VGA from the ESP32? We’ve covered this in the past – like this R&D project done by [bitluni], who then went ahead and expanded on it by connecting six displays at once. If you’ve connected your ESP32 to a VGA port and ran some test sketches, a UI library will help you upgrade your idea into a ready project in no time.

Continue reading “ESP32 Pretends To Be GPU; Gives You A Ransomware Scare”

A Slim 7400 Logic VGA Board For All Your Retro Needs

Over the years we’ve seen a number of hackers generate VGA with 74xx logic chips, but they’ve generally not been the most practical of builds. Often put together as part of a competition or purely for the challenge, these circuits are usually implemented in a mass of jumper wires and often take up multiple breadboards. Not exactly something you can toss in a drawer when you’re done with it.

But the Vectron VGA Plus, created by prolific hacker [Nick Bild], manages to improve on things considerably. Designed specifically to be smaller and simpler than its predecessors, the custom PCB contains far fewer chips than we’re used to seeing for this kind of thing. At the same time it provides a handy header row along the bottom that allows the user to connect whatever they’re working on, from microcontrollers to retro computers.

When your breadboard looks like this, it’s time for a PCB.

It looks like the PCB could still be shrunk down considerably if you’re really looking to maximize desk space, but we imagine for his purposes, [Nick] felt this was more than compact enough. Especially when you look at what the same circuit looked like during the breadboard phase. Yikes.

So, what did it take to simplify this 640 x 480 VGA interface? The short answer is adding more RAM. Wherever possible, dedicated hardware was replaced with software operations that could be performed by the externally connected device. [Nick] has provided some sample code for the Arduino that lets the microcontroller push data into the board’s memory and take control.

We can trace the origins of this project back a few years, to when [Nick] was working on adding an LCD to his homebrew 6502 computer. A few months later he put together the earlier version of this board, the Vectron VGA, before switching gears and handing VGA generation duty over to a FPGA. We’re excited to see the next evolution of this project, and given the track record of this particular hacker, we shouldn’t have to wait long before it hits our inbox.