You Can Now Bootstrap Your Amiga Without A Floppy With This One Weird Trick

October 28, 2022 by Zoe Skyforest 12 Comments

Traditionally, most Amigas were intended to boot from a floppy disk. . An Amiga can readily make its own boot floppy, but only once it’s already booted up. If you don’t have a floppy ready to go, you’re out of luck, as PCs can’t readily make them for Amigas. [Roc] whipped up the amigaXfer bootstrapping method to solve this very problem.

Shorting a couple of pins together can unlock a serial debug mode that can be used for bootstrapping the machine.

Available on Github, the amigaXfer tool is able to perform several tasks with an Amiga via its serial port. The Amiga must first be turned on while plugged into another computer running amigaXfer via serial connection. When the Workbench floppy prompt comes up, the CrashEntry feature on amigaXfer should be triggered, and the BERR and GND pins on the Amiga’s 68000 CPU should be connected just for a split second, triggering the Amiga to go into a special serial debug mode. This enables amigaXfer to take control, allowing a disk to be formatted and written with a debug bootblock, and this disk can then be used to boot the Amiga without the need for the hack.

It’s a nifty way to get your Amiga up and running if you’ve just bought it off eBay and it didn’t come with any disks. From here, you can use amigaXfer to load other programs onto the Amiga via the same serial cable you used for the bootstrapping process, too. The hack isn’t limited to just the Amiga 500, either. It should work on a range of machines, including AmigaOS versions 1.x, 2.x, and 3.x.

Unlike the Commodore 64, we probably won’t see brand new replica Amigas anytime soon, but we can dream. As always, if you’ve got ’em, send your hottest Amiga projects into the tipsline!

Protected Mode On A Z80! (Almost)

October 23, 2022 by Jenny List 27 Comments

The microprocessor feature which probably most enables the computing experience we take for granted today is protected mode. A chip with the required hardware can run individual software processes in their own environments, enabling multitasking and isolation between processes. Older CPUs lacked this feature, meaning that all the resources were available to all software. [Andy Hu] has done the seemingly impossible with a Zilog Z80, enabling a protected mode on the chip for the first time in over four decades. Has he found an elusive undocumented piece of silicon missed by every other researcher? Not quite, but it is a clever hack.

The Z80 has two address spaces, one for memory and the other for I/O. He’s taken the I/O request line and fed it through a flip-flop and some logic to call a hardware interrupt the first time an I/O call is made or when a RST instruction is executed. Coupled with a small piece of memory for register contents, and he’s made a Z80 with a fully-functional protected mode, for the cost of a few logic chips. It’s explained in the video below the break, and we hope you agree that it’s rather elegant given the resources in hand. It’s too late for the commercial 8-bit machines of the past, but it would be interesting to see what today’s retrocomputer designers make of it.

Continue reading “Protected Mode On A Z80! (Almost)” →

A man playing an accordion-like instrument made from two Commodore 64s

The Commodordion Turns Two C64s Into A Single Instrument

October 22, 2022 by Robin Kearey 16 Comments

One of the main reasons the Commodore 64 became an icon of the 1980s was its MOS 6581 “SID” sound chip that gave it audio capabilities well beyond those of other microcomputers of the 8-bit era. The SID became something of a legend by itself among chiptune enthusiasts, and several electronic instruments have been designed that generate their sound through a SID chip. Not many of those look anything like traditional musical instruments however, so we’re delighted to see [Linus Åkesson]’s new project: two Commodore 64s joined back-to-back using a bellows to form a wonderful new instrument called the Commodordion. It can be played in a similar way one plays a traditional accordion: melodies are played with the right hand, chords with the left, and volume is adjusted by varying the pressure in the bellows.

The two computers are basically unmodified, and boot Commodore BASIC like they normally would. A custom circuit board emulates a cassette player and provides the software to be loaded into memory. Both computers run the same program and can be switched between the right-hand and left-hand role by pressing a specific key combination. The software in question is called Qwertuoso, and basically maps notes and various features of the SID chip to keys on the Commodore’s keyboard.

Of course, it’s the bellows that makes this instrument a true member of the accordion family. Made from 5.25″ floppy disks and sticky tape, it forms a more-or-less air-tight system linking the two computers. The airflow in the bellows is measured through a microphone placed next to the air intake: the amount of noise generated is roughly proportional to the amount of air being expelled or inhaled. This information is then used to modulate the volume generated by the two SID chips.

By [Linus]’s own admission it’s not the most ergonomic of instruments, so we’re doubly impressed by the amount of skill he demonstrates while playing it in the video embedded below. It’s not the first time either that he has turned a Commodore 64 into a musical instrument: he previously built a church organ and a theremin. While the Commodordion may look complicated, it’s actually much simpler in construction than a mechanical accordion.

Continue reading “The Commodordion Turns Two C64s Into A Single Instrument” →

This Snappy 8-Bit Microcomputer Brings The Speed To Retrocomputing

October 21, 2022 by Dan Maloney 45 Comments

When the need for speed overcomes you, thoughts generally don’t turn to 8-bit computers. Sure, an 8-bit machine is fun for retro gameplay and reliving the glory days, and there certainly were some old machines that were notably faster than the others. But raw computing power isn’t really the point of retrocomputing.

Or is it? [Bernardo Kastrup] over at The Byte Attic has introduced an interesting machine called the Agon Light, an 8-bit SBC that’s also a bit like a microcontroller. The machine has a single PCB that looks about half as big as an Arduino Uno, and sports some of the same connectors and terminals around its periphery. The heart of the Agon Light is an eZ80 8-bit, 18.432 MHz 3-stage pipelined CPU, which is binary compatible with the Z80. It also has an audio-video coprocessor, in the form of an ESP32-Pico-D4, which supports a 640×480 64-color display and two mono audio channels. There’s no word we could find of whether the ESP32’s RF systems are accessible; it would be nice, but perhaps unnecessary since there are both USB ports and a PS/2 keyboard jack. There’s also a pin header for 20 GPIOs as well as I2C, SPI, and UART for serial communication.

The lengthy video below goes into all the details on the Agon Light, including the results of benchmark testing, all of which soundly thrash the usual 8-bit suspects. The project is open source and all the design files are available, or you can get a PCB populated with all the SMD components and just put the through-hole parts on. [Bernardo] is also encouraging people to build and sell their own Agon Lights, which seems pretty cool too. It honestly looks like a lot of fun, and we’re looking forward to seeing what people do with this.

Continue reading “This Snappy 8-Bit Microcomputer Brings The Speed To Retrocomputing” →

HP-41C, The Forth Edition

October 21, 2022 by Al Williams 46 Comments

If you have an HP-41 — arguably the best calculator ever made, you might not have noticed that there’s a version of Forth for it. The code was written a while back in assembly and will work on anything that actually emulates the device properly, such as a SwissMicros DM41X. [Calculator Clique] shows you how it works in a recent video that you can watch below.

The original code dates back to 1984, but some recent detective work by [Angel Margin] has the code running again. If you know about synthetic programming on the 41C and the oddities of its internal architecture, you can’t help but be impressed.

Of course, Forth is meant to be easy to port over, but if you read about some of the architectural challenges, you start to realize this could be one of the more difficult implementations you’ve ever seen. Don’t forget you have what is, by today’s standards, an extremely limited amount of resources.

That being said, calling the HP41C a calculator is almost a crime. It is really a tiny computer hiding inside a calculator case. Then again, the best calculators always are.

We wonder if the code would run on an emulated 41C? Were you part of the TI calculator gang? No problem.

Continue reading “HP-41C, The Forth Edition” →

A small green circuit board with a tiny OLED display

An Oscilloscope Trigger For Vintage Video Processors

October 18, 2022 by Chris Wilkinson 8 Comments

Working on retro computers is rarely straightforward, as [ukmaker] recently found out while designing a new display interface. Their oscilloscope was having trouble triggering on the video signal produced by older video circuitry, so they created the Video Trigger for Retrocomputers.

The Texas Instruments TMS9918 video display controller was used across a range of 1980s game consoles and home computers, from the well-known ColecoVision to Texas Instruments’ own TI-99/4. Substantial retro computing heritage notwithstanding, the video output from this chip was (for reasons unknown) not quite compatible with the Hantek DSO1502P oscilloscope. And without a better understanding of the video signal, it was difficult to use the chip with newer TFT displays, being designed for CRT televisions with more forgiving NTSC tolerances.

Maybe a different scope would have solved the problem, but [ukmaker] had a feeling that the ‘scope needed an external trigger signal. The Video Trigger project uses a LM1881 sync separator to tease out the horizontal and vertical sync signals from the vintage video chip, with the output piped into an ATmega 328P. Along with a smattering of discrete components, the ATmega aids the user in selecting which line to frame a trigger on, and the slope of the horizontal sync signal to align to. A tiny OLED display makes configuration easy.

If this has piqued your interest, [ukmaker] also has a great write-up over on GitHub with all the gory details. Maybe it will help you in your next vintage computing caper. Having the right tool can make all the difference, like this homebrew logic meter for hobby electronics troubleshooting. Or if you want to know more about the mystical properties of analog NTSC video, we’ve covered that, too.

Classic DOS Games On An Arduino?

October 17, 2022 by Al Williams 8 Comments

It has been a while since we’ve seen a 86Duino, but [TheRasteri] reminded us about it, with his video showing how to use one to run classic MS-DOS games. To be fair, the computer isn’t really an Arduino, it’s essentially a tiny 486 PC on an Arduino-style PCB.

If it were just running DOS games on a tiny PC, that wouldn’t be very newsworthy. However, the board by itself has no video card and, as [TheRasteri] points out, sound card compatibility is also a problem. A carrier board, however, has a tiny VGA card on it, and thanks to some work from another user, it is possible to add an ISA bus to the board if you want to plug in a legacy sound card.

The ISA hack was done neatly, but it is a bit of wiring. Instead of using a normal ISA backplane, it is possible to use a PC/104 backplane, if you have cards that will fit that bus — electrically, they are the same. The board was able to run DOOM and Quake at nearly 30 frames per second. Not bad. He did have problems getting a mouse to work, though.

Got a bit nostalgic watching him use QBasic to directly write to registers on an ISA card. If you want an old DOS machine and don’t want to tie up a lot of space, this could be the ticket. Especially if you need it to run some old piece of hardware that won’t work with modern computers. We have to wonder if anyone would make a USB to ISA adapter out of something like this. The drivers would seem to be the hard part.

We saw the 86Duino nearly 10 years ago when there were a few other x86 single-board computers around. Apparently, lots of people want to run vintage games.

Continue reading “Classic DOS Games On An Arduino?” →