TubeTime

Edit: Someone who goes by W9EO has recorded assembly videos on YouTube which you may find helpful for building this card. He is also selling completed cards if you don’t want to solder it yourself.

Growing up, I used to play some games on an AST 286 computer, including Commander Keen, Wing Commander, and a few others.

Sound in those days was primitive compared to modern machines, but I still have a soft spot for the bleeps and bloops of the OPL2 synthesizer cards (which includes the AdLib).

Recently I have been fixing up an IBM XT (with original CGA card!) and I needed a sound card. It turns out that early sound cards like the AdLib or the Sound Blaster are quite expensive on the used market, so I thought I’d make a clone of the AdLib sound card (1990 version). Being me, I couldn’t just make an electrical equivalent. It had to look as close as possible to the real thing.

Here it is.

Compare it with the original 1990 version of the AdLib sound card.

I started with Sergey’s OPL2 card and corrected some differences between it and the genuine AdLib card. Since I don’t own a physical card, I found photos on the net of the front and back of the card to use as a reference. To make sure everything matched up exactly, I figured out the design grid of the original and duplicated the traces and component placement as closely as possible. All the library footprints are custom designed to match!

The KiCad design files are available on GitHub. Mouser part numbers are embedded in the KiCad design but they are also included in the table below. The Yamaha OPL2 chipset, the YM3812 and YM3014B pair, can be found at various sources online. They were socketed on many older Sound Blaster cards, so I suspect quite a few were recovered by the scrappers.

To install the card in a computer, you’ll need to get a Keystone 9202 bracket. The KiCad layout includes a drawing showing where the holes need to be punched in the bracket. I recommend using a hand-held sheet metal punch with a 7mm or 9/32 die. You could also drill it but the punch makes a much cleaner hole.

Here’s a bonus photo showing all the parts laid out before soldering. The components were chosen to match the colors on the original card.

I brought up an additional MOnSter6502 board today. At first it failed my basic validation routines, tripping up on the LDA nn,Y instruction ($B9).

The bus diagnostic output showed that LDA nn,Y was trying to read nn+Y+1 instead of nn+Y (in my test, it accessed $0211 instead of $0210). The LEDs showed that the Y register contained the expected value, so I thought the ALU carry in signal may have been loading a ‘1’ instead of a ‘0’, thus causing the incremented value. I scoped it out and it was fine.

Then I noticed that LDA nn,X worked fine which is totally weird because those instructions are just about identical! So I physically inspected the Y register and saw this tomfoolery:

Those transistors are in bit zero of the Y register. The one on the left prevents anything but a ‘1’ from being in the LSB. The one on the right was supposed to drive the LED on so that I could tell the bit was stuck, but it decided to cover for its dead buddy. I don’t even know how this happened. It could have been shipping damage, or maybe I fat fingered a screwdriver.

After fixing it, the board worked fine. Two dead transistors and a lying LED. Gotta love transistor level debugging.

I’ve got an old Bernoulli Box (Model A210H). In the early ’80s, it was a popular way to store 10 megabytes of data in a removable cartridge format. This was also a very common IBM PC hard drive capacity back in those days, so it was great for backups. The cartridge is quite large, and comes in a protective cardboard box:

It’s been 20 years since I last turned it on. After plugging it in and flipping the switch, I smelled smoke so I quickly shut it off. I opened it up (6 screws) and removed a drive (4 screws) and pulled the controller card off of it (4 more screws). Then I noticed a blown tantalum capacitor, so I replaced it. Then I put it all back together again and powered it up with a bench supply (tantalum capacitors nearly always fail in a short circuit which makes things a little too exciting, so at least a bench supply lets me limit the current). More smoke, and another blown tantalum capacitor. I fixed it and put it back together, and powered it up with the regular power supply.

Closing the drive door made the motor spin up very sluggishly, so I checked and noticed the supply voltages were low. So I took apart the power supply and noticed a voltage adjustment potentiometer, so I set it back to the correct voltages and put everything back together. Now the motors seemed to run OK.

I tried putting in a disk and closing the door, but the drive made horrible noises. The LED on the drive blinked and the drive spun down, essentially rejecting the disk. I figured out how to open the protective window on the disk cartridge, and noticed that there were bits of sticky crap on the disk, mostly near the hub in the center. Taking apart the drive, I noticed a rubber ring that is supposed to push down on the disk in order to create some friction to spin it up. The rubber had decomposed into sticky stuff that was getting everywhere.

Bernoulli drives work on the Bernoulli principle. The disk itself is basically a floppy disk and is made from thin flexible plastic. There is a metal plate (the Bernoulli plate) that the disk spins up against. As it spins, the air in between the disk and the plate also spins and flies out due to centrifugal force. This creates a vacuum that pulls the disk very close to the plate, stiffening it so much that it acts like a hard disk platter. The drive head floats on an air cushion above the disk surface just like in a hard drive.

Unlike in a hard drive, if any dust particles get pulled into the gap, then the disk drops away from the head and nothing is damaged. The metal plate and the head both need to be very, very clean for the drive to work correctly. They are actually mounted upside down so that dust will fall away and not settle. A large fan on the back of the drive (with an attached air filter) provides positive air pressure in the case to help keep dust out. Before it enters the gap between the plate and the disk, the air is filtered a second time by a very small filter located behind the drive head.

In my drive, the head was filthy, the Bernoulli plate had some dust on it, and had a little oxidation on the back. I removed the oxidation with a file, with the idea that any patches of oxidation could produce problematic dust particles. I cleaned the working surface of the plate and the drive head with special no-lint wipes and 91% isopropyl alcohol. It’s very important not to disturb or distort the working surface, otherwise the disks will not spin right and could be damaged.

I also fabricated a replacement rubber ring and glued it onto the top of the drive spindle. In the photo below you can see the spindle with the new rubber ring. The drive head is the white thing running in the slot on the upper left. The cartridge enters from the right, and you can see some angular protrusions on the plate that open the cartridge and slide back the protective cover.

Fortunately I still had the controller card and the cable, but I had no driver software. I managed to find the DOS driver on some random website, and it actually matched up and worked! I tried it with a different disk and I was able to read back data. A few data errors occurred, but they were mostly soft errors that a couple of retries could fix. I was also able to clean up the original disk using more wipes and isopropyl alcohol. It worked fine although it had some bad sectors.

Where we left off, the MOnSter 6502 had successfully ran a basic validation suite that validated a subset of the instructions but checked every bus cycle for accuracy. Shortly afterwards I was able to get it to run the full validation suite.

BASIC ran just fine after that. It was quite slow with a 6KHz clock but it was enough to run some simple BASIC programs. Typing was difficult because my validation computer uses an Atari POKEY chip to scan the keyboard, and it latches keystrokes very slowly because of the slow bus clock.

I’ve been experimenting with increasing the maximum clock frequency. It helped to reduce the bus capacitance that I added, but if I went too low, it cut into the minimum operating frequency. With less bus capacitance I was able to get the clock up to about 60KHz, and BASIC is quite usable at this speed.

There is an issue I’ve been running into that has to do with the active bus pullups. The pullups are switched on by CCLK (first clock phase), and the pulldowns are normally changed on the CP1 edge (second clock phase). However this is done using a dynamic latch, so if the clock slows down too much, the latch will change state, causing both pullup and pulldown to be turned on at the same time. Here’s an example circuit:

The circled node is the storage node of the dynamic latch. If CP1 is off for too long, then this node can discharge, going from a ‘1’ to a ‘0’.  When that happens, the output goes high and drives a ‘1’ into the pulldown transistor when CCLK goes high. CCLK turns on the pullup at the same time. As you can see in the diagram, I’ve added a small resistor in between both transistors to limit the current.

This resistor, although it protects the transistors, also limits the maximum clock speed by limiting how fast the bus capacitance can charge up.

I’ll be experimenting with some alternative ways of protecting the transistors without slowing down the bus too much.