As you may remember, or completely not know, I have a bit of a fascination with old rotary phones. Occasionally, when people learn about this fascination, they donate their old rotary phones to me, so I have ended up with a small collection.

The other thing I have a fascination with is meetings. Well, I say “fascination”, but it’s more of a burning hatred, really. One day, a few months ago, I was in one such meeting, as I have been every day since, and I jokingly pretended to get irate about something.

One of my coworkers laughed and said “I bet if this were a phone call, you’d slam the phone down right now”, and a dread spread over me. Why didn’t I have a phone handset I could slam down? Had I really become a corporate husk of my former, carefree self, puppeteered by the vicissitudes of capitalism? “No”, I decided, “because that sentence doesn’t even make sense”.

I did, however, have a phone I could use for this project, 30% of the knowledge required, and 100% of the underestimation of how hard the other 70% would be. Armed with all these numbers, I quickly started to try to figure out how I could do this.

The phone

The phone I used is an old Siemens rotary phone, pictured in the image to the right. That image is actually not a photo of the phone, but ChatGPT’s best attempt at one, because I’m too lazy to try to find where I put the phone to take a photo of it. Rest assured, though, the image is almost exactly what the phone looks like, except with a bit more 8 and a bit less 3.

The good thing about these old phones is that nothing is soldered to anything else, which makes it possible to modify them without making any permanent changes to the phone, something which I really wanted to avoid. I don’t really think it matters much, but I don’t like breaking/altering these old phones at all. I prefer to make reversible changes where I can, and luckily the phones allow that.

The phone’s board has these metal tabs that stick out, and the cables have a corresponding connector that opens up around the tab, making decent electrical contact and using friction to make sure they don’t slip off. Since I didn’t want to make any permanent changes to the phone, I didn’t want to remove these tabs, or to solder anything onto them. I just wanted to connect a cable to them in the easiest way possible.

To do that, I designed and 3D-printed a very small connector (pictured in the photo on the right, the small, purple piece of plastic), which I used to hold a wire on top of the tab. This worked fairly well, the cable made good contact, and was relatively stable, as long as you didn’t pull on it at all.

With the connections out of the way, I could move on to the electronics themselves, and where they’d go. Another benefit of these old phones are that they’re much larger than the circuits inside them, which means that the interior is very, very roomy, with lots of space for all the extra bits I wanted to use.

The extra bits I wanted to use

Since I wanted to be able to use the phone as a meeting handset, I figured I needed something that would act as a keyboard/soundcard combo. The keyboard would be responsible for actually “hanging up” the meeting, ie sending the appropriate keystrokes to the active window to exit whatever meeting I happened to be on. The soundcard would expose a microphone/speaker combo, which could be used as an input and output device for the meeting software to play and record sound through the phone’s handset. I figured, since I’m at it, I might as well make the rotary dial work too, and have the keyboard type whatever number I dialed, just because I could.

To do all this, I needed a capable microcontroller, and I had just the thing: The RP2040 by Raspberry Pi is plenty powerful enough to be used as a sound card, and can be made to show up to the computer as a USB device.

The software

Of course, if the RP2040 was to act as a USB device that’s a combination sound card/keyboard, I’d have to spend a lot of time learning about USB devices, sound cards, keyboards, and how the RP2040 works, which is a prospect which I relished with considerable gusto, said no one ever, and especially not me. Instead, we have LLMs now, and we can make them do the dirty work we don’t want to do, like program stuff for our inane side-projects. This is literally why LLMs were created and nobody can convince me otherwise, so I decided to help Claude Opus 4.1 (the best coding model at the time) progress on its goal towards self-actualization, and got to work.

Unfortunately, Opus was only available on the $200/mo subscription, which was a bit too much for a silly side-project, so I decided to use the API instead for a few hours of coding. I mean, it’s one LLM, Michael. What could it cost? Ten dollars?

I asked Claude to write some code to turn the RP2040 into a sound card using TinyUSB, I tested it and told Claude about the way in which it didn’t work, it wrote more code, and so on. Half an hour and fifty dollars later, I realized I had spent fifty dollars on this, and that this was not sustainable because, if anything, the code was getting more and more buggy the more Claude fixed it. It was time for plan B.

Plan B

Plan B is shameful, as it contains an element of me accepting defeat, but I guess it’s actually Claude that was defeated. Be that as it may, I decided that the RP2040 sound card approach was a dead-end, as I didn’t know anything about the RP2040 or about sound cards, and that I’d have to change my tactics. I’d use a USB hub with two separate devices, one sound card and one keyboard, and the hub would join them and allow them to use a single USB cable to connect to the host computer.

I could still use the RP2040 as a keyboard, so I connected it to the phone’s hook and rotary dial, and wrote some code to measure the pulses and send keystrokes if the handset was placed on the hook. After verifying that this worked properly, I moved on to the second, and by far the hardest, part of my plan, finding an off-the-shelf sound card.

I ran to my trusty shopping website, Amazon (the AliExpress of the US), but all the USB sound cards there were a bit more expensive than they needed to be, so then I went straight to the source, AliExpress. There, I found exactly what I needed: A USB sound card for $1.69, and the sexual reference was not lost on me. Well done, AliExpress.

When the sound card arrived, I tested it on my computer, saw that it worked fine, and disassembled it. I removed the two 3.5mm jack connectors and soldered pins to them instead, with the intention that the phone’s connectors would slide over the pins instead of the metal tabs of the phone. Indeed, this worked beautifully, and the handset made a very solid connection with the sound card. I plugged the latter into my computer and confirmed that I could both listen to and record from the handset.

I then desoldered the USB connector and soldered four wires onto where it used to be, to save space. I soldered the other side of those wires to the hub, where I desoldered the corresponding connector from, and tested to see if this worked. Amazingly, it did! The computer recognized the sound card, and audio worked fine with the handset. I connected the RP2040 keyboard to the hub as well, and confirmed that that, too, worked well, sending various keystrokes when hung up (Ctrl+Shift+E for Zoom, by Ctrl+W for Meet, rm -rf / for Teams, etc).

To clarify, the RP2040 doesn’t actually know which software you’re using for the call, it just sends all the keystrokes, one after the other.

Connecting it all together

On the image to the right, you can see everything connected together. The red square to the right of the phone is the USB hub, with wires coming out of it and going to the sound card, which has been connected to the handset. On the other end, a short USB cable leads to the RP2040, which has been connected to the hook and rotary dial.

It took a bit of trial and error to find the hook connectors, but nothing too terrible. The hook is a simple switch, so the detection happens with a GPIO pin that gets pulled low whenever the phone is hung up. The rotary dial is similarly a second switch, one that opens and closes very quickly, a number of times equal to the number you just dialed. The software on the RP2040 just counts these opens and closes, waits a few milliseconds to see if there are any more of them, and, if not, simulates a keyboard typing the number it counted.

Here’s a video of the whole thing, including the hanging up money shot:

I love it.

Epilogue

I hope this post made sense, it was a bit stream-of-consciousness but this was a pretty simple build, with nothing really too involved or complicated. The most complicated part was probably the RP2040 keyboard emulation, and even that was pretty simple, because the LLM did it on its own.

If you have any feedback, questions, or hate mail, you can find me on Bluesky, or email me directly.