Building an analog looping piano

 This is the story of our new product, “Quaver: The Multiplayer Piano”. We turned an old piano into a song writing machine using magnetic pickups and a Raspberry Pi. For a less technical and more visual story, view the photo gallery on Imgur.

mike-sean-angle-1.jpg

Sean and I christening the final product at Park City mall.

 The Idea

Walking around downtown Lancaster in the summer, it’s hard to miss the pianos sitting out on nearly every block. Known as the “street piano capital of the world”, Lancaster’s Keys for the City program has provided a fun way to rock out with strangers or just have a little fun on your stroll through the city.

As musicians, Sean and I often noodle around on a piano en route to work, and more often than not we find ourselves coming up with a riff or melody worth saving. Recording to your phone is one way to preserve the idea, but wouldn’t it be cool if you could record a song and upload it to the internet right from the piano itself? Maybe even record multiple layers to make a song with friends?

We thought so too, and soon found ourselves pitching the interactive “Multiplayer Piano” to Music for Everyone, the non-profit behind Keys for the City. We were prepared to go in depth on how this would increase donations, exposure, etc, but they immediately got it and loved the idea without much persuasion. I love this city!

 The Design

We knew from the beginning that we didn’t want to rely on a display, so we tried to design around a minimal interface with only a few buttons and lights. At first we were convinced we could make it intuitive with no display at all.

multi-player-piano.jpg

However, after working through the user experience, we knew some kind of display would be required, and might even allow us to give Quaver a bit of personality. Still wanting to stay minimal, we ended up choosing the LDP-8008 from Embedded Adventures along with their Uber Display Driver PLT-2001.

controls-layout.png

Our final layout included:

 

 Initial Testing

I knew we wouldn’t have much space inside the piano, and I’ve been itching to play with the new Raspberry Pi 2, so it seemed like a good fit for this project. Plus with plenty of GPIO pins it left us many options for controlling our interface.

IMG_4412.JPG

Pictured above is a basic proof-of-concept with a record and play/pause button, along with recording and playing indicator LEDs. At this point the pi is still running the default Raspian image, however I would later find that a 20 second boot time is unacceptable for our scenario…more on that later!

 Capturing the Piano

Initially we thought we could just toss in a couple condenser microphones, some speakers and call it a day…but quickly realized our fallacy: speakers blasting right next to the microphones would surely cause a feedback loop after multiple layers, not to mention the street noise would still get picked up.

The next idea involved transposing to MIDI notes on-the-fly, however a few tests confirmed that this was much too inaccurate to rely on with an unknown or fluctuating tempo. With not much hope left, we stumbled upon our saving grace, the Helpinstill Piano Sensor:

helpinstillmod120.jpg
It’s basically a pickup like you would find in an electric guitar, but built for the strings in a piano. The sound is amazing, there is no feedback, and we can feed the signal directly into our sound card. We both breathed a sigh of relief as we knew our idea was still possible. Helpinstill FTW!

All of this is captured through a C-Media chipset based USB audio interface, Amazon is littered with these little guys and we got ours for $8!

 Playback

The signal out of the Helpinstill was pretty quiet. Amplifying at the audio interface caused a ton of noise, so we ended up using a direct box to fix some grounding issues and a clean boost pedal to get a hotter signal. I’m not convinced this is the best method, but it was the best we could do before launch.

Sean was kind enough to sacrifice some ancient Bose speakers from the 80’s, and we picked up a cheap Pyle 150W amp from Amazon to drive them.

 Software

For the software side of things, I initially considered writing a looper in ChucK. But when I realized that the open source SooperLooper can be compiled to run headless and controlled via OSC, I opted to give it a try before rolling my own.

I opted to run everything with Node.js given my familiarity with javascript and limited python experience. Here is a breakdown of the basic setup:

 

 The Build

With a working prototype in hand it was time to get down and dirty. I began the process of designing the circuit board and electronics while Sean started designing, drilling and painting the piano.

 How Not to Make a Circuit Board

After breadboarding a full working prototype with all buttons and LEDs, I decided to try my hand at soldering my own. In hindsight I would have definitely had it printed, but the tedious process of soldering this small was kinda fun once I got in the groove!

circuit board front
circuit board back

Terminal blocks would have been useful for the wires, but I forgot to order them and ended up soldering the wires directly to the board.

 Mounting the Hardware

Drilling the first hole was the hardest! I had to give Sean moral support as defacing a perfectly good antique piano was not easy to do. But once he got started I’m pretty sure he was having a blast.

drilling begins
testing fitment

We then tested the fitment of all components, beside a few minor adjustments they all fit quite nicely! Here are the sources of the buttons and LEDs we ended up using:

 Painting

Having grown up in the 80’s, we’re huge fans of retro games. We host a retro video game tournament on First Fridays in Lancaster, and we’ve slowly started collecting arcade machines in the office. It only felt natural to extend this theme to highlight the communal aspect we hope this piano will offer. Sean came up with the name Quaver, which is actually the British term for eighth note.

painting begins

Sean converted part of office into a paint booth, projected the artwork onto the piano and got to work. Judging by people’s reactions looking through the window, we’re pretty sure they thought Dexter was hard at work.

Sean hand paints the panel

While I was busy soldering that circuit board, Sean absolutely killed the paint job, even hand painting all the little pixel-perfect fonts. I also need to give huge thanks and shout out to Sean’s girlfriend wife for helping paint on some late nights. Thanks April!

 Our first hurdle

Besides running low on time, things were going fairly smooth up to this point. It was the night before the piano was due, and we finally hooked it all up and started doing some final testing.

 CPU Frequency Scaling issues

All was good until we started doing much longer songs - 30 to 40 seconds at a time. We noticed that a strange crackling would begin about 30 seconds in, but would go away sometimes after recording additional layers. Some further research concluded that this was due to the CPU ramping up to a higher frequency to meet the demands of longer audio. Apparently when the CPU changes frequency, it creates an audible noise when processing real-time audio.

I followed all the advice I could find on real-time, full duplex audio in Linux. Most resources advised setting the CPU governor to “performance” mode, but after some testing I found that this still didn’t totally stop the CPU from scaling at some point. The solution that finally worked was setting the governor to “userspace” and manually setting the frequency to 90,000 (900MHz).

 Reducing Boot Time

The other issue we ran into is that resetting the machine took at least 20 to 30 seconds…totally unacceptable if people wanted to start a new song. I had never compiled my own Linux kernel before, but I knew it was the only way to achieve ultra-fast boot times.

If you’ve never heard of it, Buildroot is quite the amazing tool for compiling Linux for embedded devices. I started with rpi-buildroot as a base and started adding all of the audio packages I would need. It took about five days full of trial and error as I had to patch just about every package to get it to compile properly, but at the end of the day I had our Raspberry Pi 2 booting in 2.9 seconds! To me, the slow boot time was always the worst part about the pi and this has blown my mind. I’m excited to try and chip away at the boot time even more as I will definitely be using the pi 2 in more projects!

 Putting it all together

final back panel

The final version of Quaver’s guts. A bit bulkier than we anticipated, but we managed to find room for everything. We have many ideas on how to simplify and shrink version 2!

come down and play! painting

We also got word that the piano’s location would be at the local Park City shopping mall food court. It would be positioned in such a way that you could see it from the stores above. We decided to paint something for the shoppers looking down. It was the tamest message we could think of :)

painting over piano logo

After a few other final touches our piano was ready for the world. The movers showed up at 9pm and we had a proper send off.

piano send off

We hope you have enjoyed reading about the making of Quaver! If you have any technical questions feel free to reach out to me at bridgman@majormega.com. For more photos check out our photo gallery on Imgur, or check out Sean’s demo of the Quaver in action:

 
89
Kudos
 
89
Kudos

Now read this

Magic with Parse in 10 lines of code

At a recent Tech Lancaster talk we gave, I was surprised to see that nobody in attendance had heard of Parse. I found myself ranting about my love for them, specifically the amount of code it saved me. The following are simplified... Continue →

Subscribe to MajorMega Blog

Don’t worry; we hate spam with a passion.
You can unsubscribe with one click.

6VKrivsvyyd7oZnUUC4g