Retrofitting an Analog Synth Into an Old Laptop

Have you ever found an old Compaq Armada E500 in the corner of a physics closet and thought to yourself, gee, wouldn't it be cool if I repurposed it as a musical instrument that makes bleeps and bloops? If so, you're in the right place. For my senior project of high school, I decided to attempt to repurpose an old laptop by turning it into an analog synthesizer—all within the span of a month.

Once I discovered the laptop, everything clicked. The grey, faded keys with various food stains? That could be made into a MIDI-like piano keyboard controller. The inch-thick exterior that fits not just a floppy disk drive, but also a wireless adapter, dvd player, and battery, all easily removable and replaceable(have we regressed as a society)? I could jam a synth in there. The built-in speaker and headphone jack? Need I say more? With these tenets in hand, I began working on the project, splitting it up into three parts: the circuitry of the synth, the keyboard, and the part where I put it all together.

Before you get any further, I'll spoil the ending; I wasn't able to complete my goal of putting a synth into a laptop(though I did complete a square/saw wave VCO with PWM, plus a sequencer!). However, I hope you'll enjoy my descent into madness as I desperately try to jam far too many wires into a laptop that is a good amount of years older than me.

Disclaimer: this will be more of a document-your-process kind of instructable rather than an actually useful step-by-step tutorial on how to build a synth-laptop-thing. If you want to learn how to build an analog synth from scratch, I recommend Moritz Klein's Youtube channel, where he gives extremely well thought out tutorials that are not only a great intro to DIY audio, but electronics as a whole. His beginner VCO tutorial is the backbone of this project.

Compaq Armada E500

Circuit

Full-size Breadboard

Perfboard

1. I used these 9cm x 7cm ELEGOO branded ones

Solid Core Wire and Jumpers

Panel Mount 1/8" / 3.5mm TRS Audio Jack Connector

Resistors

1. 100kΩ (8)
2. 1MΩ (2)
3. 68kΩ (2)
4. 14kΩ (2)
5. 1kΩ (2)
6. 47kΩ (1)
7. 33kΩ (1)
8. 250kΩ (1)
9. 1.5kΩ (1)
10. Note: I didn't have some of these, so I just made an equivalent by putting them in series.

Potentiometers

1. 100kΩ Linear (1)
2. 1MΩ Linear (1)
3. 10kΩ Linear (2)
4. 1MΩ Trimmer (1)
5. 1kΩ Trimmer (1)
6. I got this kit which includes all of the above

Semiconductors

1. TL072 IC (1)
2. BC558 (1) - PNP
3. BC548 (1) - NPN
4. 74HC14 hex inverter IC (1)
5. 1N4148 diode (1)

Capacitors

1. 2.2nF (1)
2. 1pF (1)

Microcontrollers and Boards

1. Arduino Uno(for testing) (1)
2. Arduino Nano(for final) (1)
3. Adafruit MCP4728 Quad DAC with EEPROM - STEMMA QT / Qwiic(for the sequencer) (1)

Tools

Soldering Iron

Solder

Flux

Flush cutters/Wire strippers

Fume Extractor/Good ventilation

3D-printer

Slicer(Cura)

Cad software(Fusion 360)

Calipers

Pliers

Hot glue gun

Oscilloscope

Multimeter

When I first received the laptop, I created a list of things I wanted in the final product:

1. It had to be analog. Back in ye olden days, all synths were analog, meaning that the electronics themselves generated the sound, i.e. the waveform. With the advent of computers and digital signal processing, a new type of synthesizer was born: digital. Their ability to replicate their analog counterparts with just 1s and 0s, produce new sounds impossible with analog synths (think that classic glassy 80s DX7 sound), and the convenience of not having to lug around a giant piece of circuitry made them the standard over analog ones—even to this day. However, I (and plenty others) find a certain appeal to being able to create music with just a couple of wires and components. Plus, whatever the heck this is.
2. It had to reuse components/material from old, unused/broken electronics, as I wanted to add a sustainability component to the project.
3. It had to have a cool design. I thought this was inherited by the fact that it would be in a laptop.
4. It had to have a keyboard. As a keyboard player, I wanted to be able to play it live, rather than just programming in sequences.
5. It had to have polyphony i.e. be able to play multiple notes at once. I would later find out that polyphony is not as simple as just generating multiple waves and putting them together.

I started off by booting it up one last time before I destroyed it. After thoroughly enjoying Windows XP for the first time, playing a round of minesweeper, and testing to see if the speaker + audio jack still worked, I began taking it apart to see which components I could salvage and where I could store the electronics. After removing what I thought was unnecessary, I set aside the membrane keyboard for later and began working on the circuit.

Following this guide from Moritz Klein, I started breadboarding a VCO(Voltage-controlled-oscillator) that can produce both a saw tooth and a square wave. This is the part of a synthesizer that actually generates the waveform, be it square, sin, triangle, sawtooth, whatever, which can be fed into a speaker to make music!

There's not much explaining I can do here, as I essentially just followed his tutorials step-by-step, but here are some tidbits:

1. If you end up following his tutorial, I recommend not cross-referencing what he does in the videos with the breadboard layout in the pdf, as they are different.
2. I tried using the built-in speaker wires under the keyboard, or at least what I thought connected to the speakers, but no sound came out. I also realized that I could not easily remove the audio jack, which was soldered onto the PCB, so I decided to just cut and strip off an old headphone wire I wasn't using.
3. After I finished breadboarding the circuit, I drew out the schematic to make sure I understood each part of the circuit.

In order to create actual notes, the waveform generated by the VCO is controlled by CV(control voltage), allowing the user to control the pitch of the sound through an input voltage. The "Volts/Octave" standardization, popularized by Bob Moog in the 60s, essentially maps one volt to one octave: for example, a 1 volt input would result in an A1 note to be outputted as the waveform, a 2 volt input resulting in an A2, etc. Usually this would be controlled by a sequencer; since a real one is beyond the scope of my budget, I had to build one myself in order to test the circuit.

To do this, I had to use a DAC(digital to analog converter), which converts digital signals (like from a micro controller) into analog ones. This was as simple as connecting an Adafruit MCP4728 Quad DAC directly to an Arduino.

With my limited time budget, I had to vibe-code a solution that allowed me to just input a string of notes I wanted to loop, and have it output the corresponding voltages. This ended up working very well for what I wanted it to do, though I wish I could've figured out a solution myself.

With my synthesizer and sequencer ready, it was time to test the synthesizer out. This was the best day of the entire project. Starting just a bunch of wires and components and ending up with something you can actually make music with was the coolest thing ever; I can't explain how magical it was when I finally tuned it and heard my first couple of notes.

Unfortunately, I lost all my square wave demos, which sounded way better than the ones in the video. Plus, those were all recorded from a phone microphone jammed into a pair of headphones, so there's that.

While testing, I had a realization; a VCO alone is not a synthesizer. Sure, they’re the backbone of the sound, the thing that actually produces the wave, but unlike how a note on a piano decays over time, a note generated by a VCO won’t. It’ll just keep on playing a note between C1-C6, with no ability to change volume, or even stop playing(I can’t believe I made it this far without knowing this). In a real synthesizer, the VCO is then fed into a filter, an envelope, an amplifier in order to achieve those things and shape the sound. Moritz Klein had a tutorial for those as well, but since time was running short, I decided to leave it as a bonus if I had extra time.

For the housing of the synth, I wanted something that took advantage of the modular nature of the original laptop, and after looking at each removable component, I decided on basing the housing off of the battery. Not only was it the largest removable component, but it was also directly beneath the top left section of the keyboard, which was where I wanted to put the knobs/potentiometers. Therefore, if I molded my housing to fit exactly where the battery used to be, I would be able to seamlessly hide the electronics.

I first took a photo of the battery, then imported into Fusion 360 so I could trace its general shape onto a sketch. Then, I extruded it, hollowed it out, added standoffs for the perfboard, modeled the snap fit features on the side of the housing.

Initially, I wanted the output of the synth to be the headphone jack of the laptop itself. However, I realized that since it was a SMD component, it would be really hard to desolder and reuse, so I opted for mounting a separate 3.5mm audio jack onto the housing itself. As such, I modeled a mounting hole on the side.

I was able to get two of them printed at my school, and they turned out really good. However, when I tried inserting it to the battery slot, I realized that the tolerances were way too tight, and I couldn't get it out. I eventually removed it with a pair of pliers(destroying it in the process), leaving me with one good print and the realization that once it was time to put the electronics in, I had essentially one chance as I wouldn't be able to take it out again without mangling it, and didn't have to time to go get another batch printed.

When it comes to mechanical keyboards, the keys are usually wired in a grid-like pattern, with two wires, a row and a column, associated with each key. Whenever a key is pressed, the switch mechanism connects the two wires, sending a signal to the microcontroller. However, laptop keyboards are typically membrane, not mechanical. Membrane keyboards work similarly, though instead of rows and columns of wires, the wires are "traces" built into two separate sheets/membranes; when a key is pressed, the sheets are pressed together, creating the specific connection for that point. These traces are then led into a 27-pin ribbon cable that the computer deals with. The catch is, since the traces aren't nicely wired up into a grid pattern, I can't easily figure out which traces correspond to which keys.

In short, each key press results in any two of the 27 pins being shorted, and unless I wanted to brute force every two-pin combination for each individual key(351 unique two-pin combinations!), I needed to open the keyboard up and visually see which keys corresponded to which traces, and where each trace is located on the ribbon cable.

Following this video by Nick D. Clements, I began tracing each key back to the ribbon cable, color coding as I went. The white indicators and lines on the blue-green membranes weren't exactly the clearest, so it took me a while to draw them all out, but by the end I knew which two wires corresponded to every key on the keyboard.

Keyboards typically have a microcontroller that processes its inputs; however, since I was working directly with the membrane keyboard hardware, I needed to have my own microcontroller that processed keyboard inputs, which would then output the corresponding control voltage to the synth.

To do this, I would need a matrix that the Arduino Keypad library could process, so that I could map a note(e.g. "C#2") to the two connections that input that particular note. For example, pins 17 and 13 are connected whenever that the C#2 key is pressed, so that point in the matrix should have the coordinates (17, 13), and the point itself should be the string 'C#2.' I overlaid my trace drawing over an image of the physical keyboard—so that I could see which note corresponded to which traces—and wrote them all into a spreadsheet. My Arduino Uno only had 20 pins I could use as inputs, so I tried to use as few wires as possible in my matrix. I then formatted my spreadsheet data into an array that the Keypad library accepted.

Once everything was ready, I powered my Arduino on and tried to get a character to output from my serial monitor after pressing the corresponding keys. The Arduino itself was working fine, as manually connecting two pins together would produce the correct note output, but whenever I pressed an actual key on the keyboard to make the connection, nothing would happen. After closer inspection, I realized that this whole time, the ribbon cable itself was broken, and I had been doing all this work for nothing; the keyboard was unusable. I could technically repair it, but I decided that transferring the circuit onto a perfboard would be a better use of my time.

Although I did not exactly follow proper layout rules when designing this, I am quite proud of how I managed to fit all those components within the limited space I had(9cm x 7cm perfboard). If I were to do this again, I would absolutely go down the PCB route instead. However, I did enjoy the process of drawing it out by hand; plus, I didn't have to wait for any manufacturing and shipping times.

When it came to soldering, I first placed all my components onto the board as they were in the layout. I then flipped it over, tried to make as many connections as I could using the component leads, and began soldering each connection. This process took me around three days, and afterwards, I checked each connection on the schematic to see if I had messed anything up. Surprisingly, I had little to troubleshoot, minus a couple connections.

Eventually, I got tired of my flimsy breadboard power supply and decided to make a slightly more permanent one. I wanted to make one that could actually plug into an outlet, but since I was afraid of electrocuting myself on accident, I stuck with my two 9v batteries. Doesn't it look silly?

With (almost) everything in order, I started the process of putting it all together. First, I mounted all my potentiometers: one on the side, two on top. Then, I made a permanent version of the sequencer using an Arduino micro, which was smaller and fit inside one of the compartments in the laptop. In order to connect the perfboard to my mounted potentiometers, I needed some kind of connector, so I settled on the only thing I had, duponts/jump wires. Since I didn't have headers, I cut my female-to-female connectors in half—which felt like a crime—and soldered them where they needed to be, with hot glue at the base for strain relief.

At this point, with three days to get it working until it was time to present it, I realized that I severely underestimated how hard it is to "put things together."

Because I made the housing perfectly snug in the battery hole, if I wanted to thread any wires through it, I would needed to squish them all within the height of the housing, slide the housing in, use tweezers to pull them through the hole, and then connect all the wires. This all could've been avoided had I left one side of the housing open(see drawing above), but alas, I had two days left, and I hadn't even started my presentation yet.

I squish the wires down, push the housing in, thread them out, and plug in all the connectors. Theoretically, it should work, but it doesn't. No big deal. I take it all out and test it again. The circuit works. I put it back, threading all the wires through. No sound comes out. I take back out. It works again. I put it back in. No sound. Somehow my circuit works outside of the laptop, but never inside. Eventually, my wave starts to look a little funky, possibly due to the layout of the perfboard(despite this not happening when I first tested it). I even managed to get a sin wave at one point. It's the night before my final day to work on this, and I'm going insane. Clearly something is going wrong with the connections whenever I thread it through the computer, but since I'm working with such a cramped space, I can't see what the issue is.

During my fourth and final attempt, one of the wires seemed to be getting tangled when I was testing it with the housing inside the laptop, forming what looked like a loop out of the hole. After fiddling around with my tweezers to no avail, I realized that since it was probably just one of my potentiometer wires(which I made long in case something like this happened), I could just cut it and everything would be fine. In a wire-induced frenzy, I pulled out my flush cutters and snipped it, only to find that the wire was not in fact a potentiometer wire, but my other wire, my very important other wire that connected two very important points in the circuit, and I lost all hope. Thoroughly exhausted, I decided that I would just have to present my breadboarded synth—no laptop.

Wow. It sucks to have the conditions spelled out for you, having several parts of the project working, and then when it comes to putting it all together, it all crashing down. While presenting my senior project, my live demo ended up not working for an unknown reason(I pulled an all-nighter writing my presentation, so no testing beforehand), and I had to show off the same outdated recordings I showed to you earlier. When it was working, the square wave sounded so good, but since I lost the recordings and the synth is defunct, all I can show for my work was a measly little saw wave recorded by my phone's microphone.

As a postmortem, here as some of the reasons I think I failed:

1. Lack of planning. I cannot stress this enough. The laptop thing was sort of a last minute idea; I was originally just going to build an analog synthesizer, but I found the laptop when senior projects started, and the pull of a laptop-synth hybrid was just too great. If I had planned months in advance, going over every detail, every possible pain point, learning how a VCO works; I would have been able to avoid a lot of the troubles I encountered, and actually have a working final product.
2. Multiple branches of work. This goes along with a lack of planning, but because I was trying to work on multiple things at the same time(breadboarding, keyboard stuff, perfboard), each one evolving at their paces, I wasn't able to account for the issues that arose when I tried to combine each aspect into one thing.
3. Doing too much. Sort of the same thing, but I probably should've just stuck to trying to accomplish one or two goals, considering my time constraints and experience with the subject matter.
4. No prototyping. Even though I probably couldn't have actually prototyped due to the nature of the project(there's only one laptop), expecting everything to work first try is just silly. AAAHHHH it all comes back down to planning. Everything is planning.
5. No test points. Connecting three potentiometers, a power supply, and an arduino to a circuit board with no easily accessible test points is a bit of a challenge. I should've at least added some exposed, easily clippable wires, which would've done wonders for testing and prevented many of the connection related failures I had towards the end. Also, I've learned that I should use headers instead of soldering dupont wires directly onto the board.

On a happier note, working on this project was one of the coolest things ever, and I am lucky to have had the time and resources to do it(thanks to my parents). Plus, I was able to apply the skills(soldering, CAD, coding, circuit analysis) that I've developed over the years in previous projects; without those, I wouldn't have been able to make it past even the first step.

Anyways, I hope this inspires you to find your own crusty old laptop and do something with it. And maybe plan a little more, while you're at it. Thanks for reading!

Sources:

DIY VCO Part 1: The analog oscillator core anyone can build

Make: Analog Synthesizers

Qwerty Keyboard to Midi Piano : 8 Steps - Instructables

How to Connect a PC Keyboard to an Arduino?

https://www.reddit.com/r/arduino/comments/rv6rhj/laptop_keyboards_revived_with_arduino/#lightbox

DIY SYNTH PSU: How to design a simple dual power supply

How to build a DIY 3X VCO module from scratch

COMPAQ ARMADA E500 노트북 분해(Laptop disassembly) https://www.reddit.com/r/arduino/comments/1c3vkin/how_to_mount_in_3d_print_enclosure/?rdt=64149

Make a Keyboard From a Keyboard - Part 1

https://www.khanacademy.org/science/electrical-engineering/ee-circuit-analysis-topic/ee-resistor-circuits/a/ee-voltage-divider

https://web.mit.edu/klund/www/weblatex/node2.html

https://www.perfectcircuit.com/signal/learning-synthesis-envelopes-1