It’s Bad Apple, But On A 32K EPROM

February 19, 2022 by Jenny List 12 Comments

The Bad Apple!! video with its silhouette animation style has long been a staple graphics demo for low-end hardware, a more stylish alternative to the question “Will it run DOOM?”. It’s normal for it to be rendered onto a screen by a small microcomputer or similar but as [Ian Ward] demonstrates in an unusual project, it’s possible to display the video without any processor being involved. Instead he’s used a clever arrangement involving a 32K byte EPROM driving a HD44780-compatible parallel alphanumeric LCD display.

While 32K bytes would have seemed enormous back in the days of 8-bit computing, even when driving only a small section of an alphanumeric LCD it’s still something of a struggle to express the required graphics characters. This feat is achieved by the use of a second EPROM, which carries a look-up table.

It’s fair to say that the result which can be seen in the video below the break isn’t the most accomplished rendition of Bad Apple!! that we’ve seen, but given the rudimentary hardware upon which it’s playing we think that shouldn’t matter. Why didn’t we think of doing this in 1988!

Continue reading “It’s Bad Apple, But On A 32K EPROM” →

Pi Pico Emulates ROM For Speedy Retro Hacking

September 2, 2021 by Tom Nardi 22 Comments

If you’ve ever worked on a system that loads its software from a ROM or EPROM, you know how much of a hassle it can be to make frequent changes to the code. Pulling the chip, flashing it, and sticking it back into the socket each time you change a line isn’t anyone’s idea of a good time. Which is why [Nick Bild] has come up with the PicoROM, a way to emulate a ROM chip using the Raspberry Pi Pico.

With the Pi Pico standing in for the original ROM, updating firmware takes a fraction of the time and doesn’t require you to actually disconnect any of the hardware. [Nick] had done something similar with FPGAs in the past, but the far cheaper and easier to work with Pi Pico makes this version particularly appealing. The secret to getting it to work is the overclocking potential of the Pico, which he says has been pushed to 400 MHz for this particular application.

The downside is that you can’t access the Pico’s onboard flash when the chip is running that fast. To get around that limitation, all of the code is loaded into the microcontroller’s RAM. With a healthy 264 KB of memory this isn’t really a problem when emulating 32 KB chips, but [Nick] says his method would quickly fall apart for larger ROMs.

Beyond the Pi Pico itself, [Nick] is using a trio of 74LVC245AN 8-bit logic level shifters so the chip can talk to the 5 V logic of his homebrew 6502 computer. With everything wired up on a simple breadboard, PicoROM has no trouble serving up the operating system as it hums along at 2 MHz.

Of course, a modern high-performance microcontroller isn’t strictly necessary. In the past we’ve covered devices that could emulate an EPROM using 1990s era silicon.

Psion Organiser with a Pico memory pack.

Proto-PDA Regains Its Memory With The Help Of A Raspberry Pi Pico

August 26, 2021 by Dan Maloney 2 Comments

Remember the Psion Organiser? If you do, chances are you were an early adopter, as the 8-bit pocket computer had its heyday in the mid-1980s. Things have come a long way since then, of course, but just how far is illustrated nicely by the fact that a Raspberry Pi Pico can stand in for the Psion’s original memory packs.

Like many of the early attempts at putting a computer in your pocket, the Psion II had removable modules, which were dubbed “Datapaks”. The earliest versions of the Datapaks were little more than an EPROM chip on a small PCB, and the technical limitations of the day plus the quirky way of addressing the memory made it possible for [Amen] to mimic a Datapak using a modern microcontroller.

The first version was a breakout board that extended out of the Datapak slot significantly, with a Pico, OLED display, SD card slot, and a bunch of pushbuttons. That prototype proved that the Pico was indeed fast enough to fool the Psion into thinking a legit Datapak was plugged in. [Amen] later refined the design by making a board that stuffs everything into the Datapak slot, with the exception of the OLED which still dangles out where it can be seen. He puts the faux memory to the test in the video below.

It’s great to see groundbreaking tech of yesteryear like the Psion being taken care of and returned to use. We’ve seen others try before; here’s a hack that uses a Pi to connect a Psion Organiser to the internet through its RS-232 serial port.

Continue reading “Proto-PDA Regains Its Memory With The Help Of A Raspberry Pi Pico” →

Build A Barebones 68000

July 30, 2021 by Bryan Cockfield 32 Comments

The 68000 chip was ubiquitous in the computing world well past its heyday in the 1980s. It was used as the basis for many PCs and video game consoles, and even in embedded microcontrollers. Now, one of its niche applications is learning about the internal functions of computers. 68000 builds are fairly common when building homebrew computers from scratch, but projects like these can be complicated and quickly get out of hand. This 68000 project, on the other hand, gets the job done with the absolute minimum of parts and really dives into the assembly language programming on these chips. (Google Translate from Spanish)

[osbox68] built this computer by first simulating its operation. Once he was satisfied with that, the next step was to actually build the device. Along with the MC68008 it only uses two other TTL chips, a respectable 32 kilobytes of ram, and additionally supports a serial port and an expansion bus. A few 74-series chips round out the build including a 74HC574 used for debugging support. With a custom PCB to tie everything together, it’s one of the most minimal 68000 builds we’ve seen that still includes everything needed to be completely functional.

After all, including the TTL and 74XX chips the entire circuit board only uses 10 integrated circuits and a few other passive elements for a completely functional retro computer. [osbox68] also includes complete schematics for building a PCB based on these chips to make construction that much easier. Of course, emulating an old microcontroller instead of using TTL components can save a lot of real estate on a PCB especially if you’re using something like an FPGA.

Just How Vulnerable To Accidental Erasure Are EPROMs Anyway?

June 29, 2021 by Dan Maloney 45 Comments

On the scale of things worth worrying about, having to consider whether your EPROMs will be accidentally erased by some stray light in the shop is probably pretty low on the list. Still, losing irreplaceable data can make for a bad day, so it might just pay to know what your risks really are.

To address this question, [Adrian] set out to test just how susceptible to accidental erasure some common EPROM chips are. An EPROM, or “erasable programmable read-only memory”, is a non-volatile memory chip that can be programmed electrically and then erased optically, by exposing the die inside the chip to light at a specific wavelength, usually in a special chip erasing tool. But erasure can also happen in daylight (even if it takes a few weeks), so [Adrian] cooked up an experiment to see what the risk really is.

He exposed a selection of EPROMs with known contents to UV and checked their contents. Three of the chips had a simple paper or foil label applied, while one had its quartz window exposed to the UV. As expected, the unprotected chip was erased in just 30 minutes. The covered chips, though, all survived that onslaught, and much more — up to 780 minutes of continuous exposure.

So rest easy — it seems that even a simple paper label is enough to protect your precious retro EPROMs. It’s a good data point, and hats off to [Adrian] for taking a look at this. But now we can’t help but wonder: what would a little sunscreen applied to the quartz window do to erasability? Sounds like a fun experiment, too.

Continue reading “Just How Vulnerable To Accidental Erasure Are EPROMs Anyway?” →

Glasgow Uses An FPGA As An Embedded Systems Multitool

August 10, 2020 by Al Williams 13 Comments

Everyone who builds embedded systems wants tools to help build and debug systems faster, so it isn’t uncommon to see boards outfitted with various tools like serial port sniffers. We’ve seen a few incarnations and the latest is Glasgow. The small board uses an FPGA and claims to do the following:

UART with automatic baud rate determination
SPI or I2C
Read and write common EEPROMs and flash chips
Read and write common EPROMs including a data rescue function
Program AVR chips via SPI
Play back JTAG SVF files
Debug ARC and some MIPS CPUs
Program XC9500LX CPLDs
Communicate to several wireless radios and CPUs
Do sound synthesis
Read raw data from floppy drives

The revC board is the first to be relatively functional and sports 16 I/O pins operating at up to 100 MHz, although the documentation hints that 6 MHz might be the top of what’s easily accomplished. The software is written in Python and the iCE40 FPGA toolchain that we’ve talked about many times in the past.

This already looks like a useful tool and the reconfigurable nature of FPGAs makes it a good platform to expand. The documentation discusses the difficulty in debugging things for the board, so the base software offers support such as a built-in logic analyzer to help.

We have seen dev boards become bench tools, like using the iCEstick as a logic analyzer. It’s nice to see dedicated tools like this one built up around the speed and versatility of FPGAs.

Continue reading “Glasgow Uses An FPGA As An Embedded Systems Multitool” →

Years Don’t Dim The Shine Of These Curious Gadgets

January 13, 2019 by Donald Papp 4 Comments

[Maarten Tromp] recently took the time to document some of the unusual and creative electronic projects he received as gifts over the years. These gadgets were created in the early 2000’s and still work flawlessly today. Two of our favorites are shown here: Hardware Tetris Unit (shown in the image above) and Heap of Electronic Parts.

The “Heap of Electronic Parts” makes sounds when in sunlight.

Heap of Electronic Parts was a kind of hardware puzzle and certainly lives up to its name. It’s a bunch of parts soldered in a mystifying way to the backs of four old EPROMs — the chips with the little window through which UV is used to erase the contents. Assured that the unit really did have a function, [Maarten] eventually figured out that when placed in sunlight, the device ticks, buzzes, and squeals. [Jeroen] had figured out that the EPROMs could act like tiny solar cells when placed in sunlight, and together the four generate just enough power to drive an oscillator connected to a piezo speaker. It still chirps happily away, even today.

Hardware Tetris plays in a terminal window.

Hardware Tetris Unit was a black box intended to be plugged into a serial port. With a terminal opened using the correct serial port settings, a fully-functional Tetris game using ASCII-art graphics could be played. It was even self-powered from the serial port pins.

Inside Hardware Tetris is an AVR microcontroller with some level shifters, and the source code and schematics are available for download. 14 years later, computers no longer have hardware serial ports but [Maarten] says a USB-to-serial converter worked just fine and the device still functions perfectly.

There are a couple more devices documented on [Maarten]’s gifts page, including a Zork-inspired mini text adventure and a hardware board that does some trippy demos on an old Nokia color LCD. [Maarten]’s friend [Jeroen Domburg] (aka Sprite_tm) had a hand in creating most of the gadgets, and he’s someone whose brilliant work we have had the good fortune to feature many times in the past.