Let's Build a Turntable Synth!

Let's Build a Turntable Synth!

Takumi Ogata · 08/27/26

Sampler synthesizers are fun to make music with! This type of synth records any sound, whether musical or non-musical, and transforms it into a playable instrument. Often, a sampler's control interface consists of knobs and a keyboard.

CASIO SK-5 (Photo Credit: Perfect Circuit)

These are perfectly fine, of course, but what if the control interface is something a bit unusual? One idea is to take inspiration from a turntable. A vinyl record contains recorded sounds and plays them back as it spins on a motor. You’ve probably seen DJs manually move the record with their hands to perform with it like an instrument.

What if you could build a spinning interface to control a sampler synthesizer?

Items Needed

Software

Project File

The project files (download zipped folder) includes:

  • Plugdata patches
  • Schematic
  • STL
  • Audio samples

Hardware Design

The general idea is to build an instrument that can record external sounds, such as from a synth, and play them back by manually spinning a disc.

If you spin faster, the playback speed increases, which results in a higher pitch. Spinning counterclockwise results in reverse playback. You can perform by altering the speed and direction, so this rotating interface has the potential to be very expressive!

But how do you measure something rotating? You would need some sort of electronic component that can measure rotational motion. Well, a potentiometer works by rotating a knob. But the issue is that you can’t keep turning it once you reach either the maximum or minimum position.

So you need something that you can rotate forever. You may have noticed a knob in a car audio system that seems to rotate indefinitely. Inside an interface like this, there's a component called a rotary encoder! As you can see, you can keep rotating it.

While it’s kind of hard to show in this GIF, the encoder clicks as you rotate it. And every time that “click” happens, the encoder outputs a pulse. To get the rotational speed from this, you could either measure the time between each pulse or count the number of pulses every quarter of a second.

This looks really promising! To get started prototyping, you can 3D print a disc that can be slapped onto the encoder. Then, you can hook up the encoder to a microcontroller.

The Daisy Seed can read the encoder's pulses, and you can program it to calculate the rotational speed from those pulses. The Seed can also handle audio input and output, so you can program it to record the input sound and play it back as you spin the disc!

Daisy Seed3

Programming the Encoder

First task is to see what the encoder data looks like. For this tutorial, let's use Plugdata as it is quick to set up and easy to program with any Daisy board. You can install it from their download page.

Encoder_Print.pd

This patch simply reads encoder data and displays it on a serial monitor using [print] so you can see it! The [change] object filters out repeated values. This patch, along with other files in this blog, can be downloaded from this link.

When you compile this patch with the custom JSON file, encoder.json, in the same download folder, the [r Encoder @hv_param] object outputs the encoder value read from the Daisy's D26 and D25 pins.

Here's what encoder.json looks like:

{
    "name": "turntable",
    "som": "seed",
    "audio": {
        "channels": 2
    },
    "components": {
        "encoder": {
            "component": "Encoder",
            "pin": {
                "a": 26,
                "b": 25,
                "click": 13
            }
        }
    }
}

So, this JSON file maps the [receive] object to the D26 and D25 pins.

Let’s flash this program to the Daisy Seed!

Click the "Main menu" icon at the top and select "Compile". After installing the toolchain, select "Custom JSON..." as the target board and open the custom JSON file mentioned earlier. Then, set "Debug printing" to "Yes". Since the patches you'll compile and flash later in the tutorial will involve recording sound, let's set the "Patch size" to "Big + SDRAM" while you're at it. Before flashing a program, the Daisy needs to be put into a flash-able state. Hold down the BOOT button while inserting the USB cable into the Daisy. Now, click the "Flash" button in Plugdata.

Using the Arduino IDE's Serial Monitor (you can watch this video to learn how to set it up for the Daisy), you should see a value of +1 appear when you twist the encoder, followed immediately by a 0.

So that 1 represents the pulse mentioned earlier. The 0 is the output when the encoder isn't being twisted. Since this value is constantly being output, that's why we need [change]. When you rotate counterclockwise, you should see a -1. That’s helpful to know since you also want to know the direction of rotation!

Calculating Rotational Speed

And you know what, let’s spin fast!

Just by looking at the serial monitor, you can easily tell when you're spinning fast by the sheer number of 1s! So, the number of pulses generated corresponds to the speed. The following patch counts the number of pulses every quarter of a second and outputs a value between 0.0 and 1.0 based on the total number of of pulses. This is your rotational speed!

Speed_Measuring.pd

Whenever the encoder is rotated and a pulse is generated, the output of [int 1] increments by one. The resulting value is stored in the first [f] object in the chain, which outputs that value every 250 milliseconds when triggered by [metro]. That total value is then scaled between 0.0 and 1.0 on the right side of the patch using a combination of [-], [/], and [pow] objects. The [5] and [22] are the set minimum and maximum pulse counts. If the total number of pulses is five every quarter of a second, the output value is 0.0 (slow). If the total number of pulse is twenty-two, the output value is 1.0 (fast). Note that the stored value of [f] is reset to zero immediately after outputting.

Now that you have the speed, you can map it to the playback speed of a recorded sound! But first, let's put together a circuit that consists of input and output jacks, a button, and an LED.

Here's what the custom json (turntable.json) for this circuit looks like:

{
    "name": "turntable",
    "som": "seed",
    "audio": {
        "channels": 2
    },
    "components": {
        "encoder": {
            "component": "Encoder",
            "pin": {
                "a": 26,
                "b": 25,
                "click": 13
            }
        },
        "ribbon": {
            "component": "AnalogControl",
            "pin": 15
        },
        "sw": {
            "component": "Switch",
            "pin": 17
        },
        "led": {
            "component": "Led",
            "pin": 19,
            "invert": "false"
        }
    }
}

`sw` is the button connected to pin D17, and `led` is the LED connected to pin D19. We'll discuss what `"ribbon"` does later.

Here's a patch that takes audio input ([adc~]), which is then recorded to a buffer (the Array named "sampler") using the [tabwrite~] object.

Speed_Pitch.pd

When you press the button ([r sw @hv_param]), whatever audio you're sending into the Seed will be recorded for four seconds (192,000 samples = 4 seconds of audio). The LED ([s led @hv_param]) lighting up indicates that a sound is being recorded.

The left side consists of the [phasor~] object, which reads through the buffer using [tabread4~]. Altering its frequency changes how fast the audio is being read (playback speed), which also affects the pitch. The frequency is mapped to the speed value calculated earlier. It's also worth noting that the direction of rotation determines whether the frequency is positive (clockwise rotation) or negative (counterclockwise rotation). A negative frequency results in reverse playback!

After compiling and flashing the patch, record a sound from an external synth and start spinning the disc! It’s super cool and fun to control a sound by spinning a disc, isn't it? That said, you may want more stable control over the pitch so that you don’t constantly stray from the key of a song you're working on, for example. It’ll be hard to find the speed at which the pitch matches the original and then maintain that motion.

Pitch VS Position

Let’s revisit what inspired this project in the first place, the turntable! It works by moving through the recording. The instrument as it is now is just controlling the speed of playback and is independent of where you are in the recording. It's like the spinning gesture is only controlling the speed of a record player's motor.

So, let's move through a recorded sound's position instead! By using a synthesis technique called granular synthesis, the pitch is not affected by how quickly or slowly you move through the recording! This synthesis technique works by playing only a few milliseconds of recorded sound at a time (called a grain), and you can loop multiple grains with slightly different lengths. By changing the grain's starting position, you can smoothy move through the recording!

Here's a great video that explains more about granular synthesis in more detail. The [Granular_Synth] abstraction in this tutorial draws heavily from it.

Here's a patch (Turntable_Granular_Without_Pitch_Control.pd) that lets you control the sample position as you spin the disc.

Turntable_Granular_Without_Pitch_Control.pd

Every time a pulse is generated, you move forward through the recording by 1/250 of its total length ([/ 250]) . After 250 pulses, you reach the end of the recording and start over ([% 250]).

Turntable_Granular_Without_Pitch_Control.pd

The position value mentioned earlier is mapped to [Granular_Synth]'s position input. The video linked earlier explains this portion of the patch and granular synth itself in more depth.

Recording yourself counting to four or playing a musical scale in order on your synth will clearly demonstrate how this patch works. Give it a try! As you spin the disc, it’s like you're exploring through sound with an engaging physical motion!

And you can still add pitch control to this patch (Turntable_Granular_With_Pitch_Control.pd). At reasonable speeds, the pitch doesn't change much. But once you reach above a certain speed, you can start to hear the pitch change more as you spin faster!

Turntable_Granular_With_Pitch_Control.pd

Now, it’s starting to feel like a really fun instrument that you can make music with! Let's add one more thing. Your right hand is all set to spin the disc, and you can use your left hand to control the granular synth’s grain size parameter with a ribbon sensor ([r ribbon @hv_param]). When this parameter is set to a low value, the sound will be “grainy” and “glitchy”. When it’s set to a high value, the sound will be more “blurred out”. The ribbon sensor is also mapped to the reverb ([Space]) amount. Finally, the sound will be muted when you're not touching the ribbon sensor. The sensor outputs a value close to zero when it isn't being touched, which causes [> 0.01] to set the [*~]'s right inlet to zero.

Turntable_Synth_Main.pd

Hardware

This instrument will consist of the rotary encoder disc, ribbon sensor, audio jacks, the Daisy Seed, and a button with an LED inside it.

And these components are going to be housed in a 3D printed enclosure!

The top panel can be screwed on to the enclosure by using a heat-set insert. It works by using a soldering iron to heat it up and melt the surrounding plastic. Once the temperature drops, the insert is locked in there.

To make the disc look more turntable-y, grooves are added!

Conclusion

After assembling everything, you're ready to see this instrument in action! When you press the button to record, the LED will turn on. I included a piano sample in the project folder that you can record into the instrument by playing it from your laptop or smartphone. The spinning gesture has a very meditative quality to it, so it’s really well suited to creating ambient music! It sounds awesome with a sample that's a bit more aggressive too! This instrument can go from immersive ambient to chaotic glitch music!!

If you want to hear this synth in action now, you can watch the video version of this tutorial linked at the start of this blog!

I hope you have fun building this turntable-inspired synth and get immersed in playing it!

If you have any questions, please feel free to ask in this forum thread about the project.

Back to blog