Tackling Jitter and Smooth Analog Inputs with the Raspberry Pi Pico and MCP3204

Introduction

So, I was messing around with a project using those endless pots that everyone loves (you know, the ones that turn and turn and turn and never stop turning). The goal was to use the Raspberry Pi Pico and the MCP3204 ADC to read the pots’ values. Simple enough, right? Well, turns out the universe had other plans. While everything worked perfectly fine on my trusty Bluepill using the Arduino framework, when I moved the code over to the Pico, things went… not so smoothly.

It was weird. The knobs would sometimes hang, the readings would drop out, and worst of all, they felt like a jittery mess. I was thinking, “Alright, maybe it’s just me. I’ll work through it.” Spoiler alert: It wasn’t just me.

The Problem

Here’s the deal: on the Bluepill, everything was peachy—no issues. But on the Pico, it was as if the endless pots decided they’d become ‘just a bit’ unpredictable. The jitter was erratic, and it was really starting to mess with my head. I tried all sorts of things: debounce techniques, bypass capacitors (I even went full-on “deadbug mode” and soldered them directly onto the output pins of the pots), software filters… you name it. Nada. No improvement.

I was getting desperate. The jitter wasn’t just random noise, it was dancing in my face, mocking me. But it wasn’t until a little accident happened that the truth revealed itself.

The Breakthrough

While debugging another feature, I noticed something strange. When I had the debug printing turned on, the knobs felt way better. Like, so much smoother. Almost zero dropouts, and the movement detection thresholds were way lower than what I had originally set. It hit me: something was flooding the system. The debug print was clearly slowing things down, and suddenly, the jitter was gone.

At that moment, the lightbulb went off. This wasn’t just hardware interference or software bugs—it was something simple. The system was overloaded with data, and it couldn’t keep up with all the readings from the pots in real-time. And somehow, the debug print was giving it just enough breathing room. Maybe there was a solution in there somewhere.

The Solution

After some thought, I decided to experiment with a small delay. But not just any delay—I didn’t want to block the whole system and ruin the real-time feel of the project (since, well, it’s for music, and you don’t mess with musical timing). So, I added a non-blocking delay to space out the potentiometer readings, giving the system some time to catch its breath.

I added a 10ms delay. Sounds small, but the difference it made was huge. Suddenly, the jitter was gone. The knobs felt responsive, smooth, and I could finally reduce the jitter threshold from some insane number like 40 down to 1. Everything was snappy, and most importantly—no more erratic behavior.

You might think, “Wait, 10ms? That’ll ruin the feel of the thing, right?” But here’s the kicker: My brain couldn’t tell the difference between 10ms and 0ms. And in music? The responsiveness felt snappy. It worked.

Here’s how I did it:

The Non-Blocking Delay Code

void EndlessPotentiometer::updateValues() {
    uint32_t now = to_ms_since_boot(get_absolute_time());
    if (now - lastUpdate < 10) { // Non-blocking delay of 10ms
        return;
    }
    lastUpdate = now;
    
    // Read potentiometer values here
    int pot_value = read_potentiometer(); // Replace with your actual ADC reading
    
    // Process potentiometer value
    process_pot_value(pot_value);
}

With this simple trick, your system can read the pots without freezing, and you get a smooth and responsive experience.

Takeaways

• Jitter isn’t always random noise—it can sometimes be caused by the system being overwhelmed with too much data too quickly. Slow it down a little, and it might just smooth out.
• Small delays don’t necessarily ruin real-time performance. In fact, they can actually improve it when done carefully (and 10ms is practically invisible to your brain).
• If you’re working on music or any real-time project, remember that smooth feels just as important as snappy. A little breathing room for the system can go a long way in making the whole thing feel more polished.

So, if you’re working with ADCs, endless pots, and jitter, don’t jump straight to the expensive hardware fixes. Sometimes, a simple timing tweak is all you need.

And with that, I’ll leave you with this: never underestimate the power of a little delay in the right place. Your system might thank you for it.