Smoothing Frequency Detector Servo

Yes - what you’re seeing is typical pitch-tracking jitter from FFT-based detection, especially when a tone has strong harmonics or the detector briefly "locks" to 1/2x or 2x of the fundamental.

Short answers

1) Built-in smoothing / hysteresis?

The Frequency Detector skill does not provide a user-facing smoothing window or hysteresis control for the detected frequency output.
So if the output is bouncing, the usual fix is to smooth the value yourself before driving the servo.

2) Will ServoSpeed help?

Yes, if the servo is being moved by ARC’s servo position updates, ServoSpeed can help reduce chatter by slowing how fast the servo responds to rapid position changes.

However, for best results, I’d still recommend rate limiting / filtering the frequency in a script before mapping it to the servo. That gives you control over:

• smoothing
• deadband / hysteresis
• update rate
• ignoring octave jumps

3) How to stabilize pitch tracking?

Best practice is usually a combination of:

• average the detected frequency
• ignore small changes with a deadband
• reject octave errors by clamping changes that are roughly half or double the previous value
• update the servo at a fixed interval instead of reacting to every fluctuation

Recommended ARC approach

Instead of sending the detected value straight to the servo skill, use the $fd_freq variable in a script and smooth it first.

Simple smoothing example in JavaScript

This example:

• reads $fd_freq
• applies a simple moving average
• ignores tiny changes
• maps the result to servo positions on D1

var alpha = 0.2; // lower = smoother, higher = more responsive
var deadbandHz = 8;
var filtered = 0;
var lastServoPos = 90;
var lastFreq = 0;

while (true) {
  var raw = parseFloat(getVar("$fd_freq", "0"));

  if (raw > 0) {
    if (filtered == 0) {
      filtered = raw;
    } else {
      filtered = filtered + alpha * (raw - filtered);
    }

    // Ignore tiny changes
    if (Math.abs(filtered - lastFreq) >= deadbandHz) {
      lastFreq = filtered;

      // Map 200-800 Hz to 30-150 degrees
      var pos = Math.round(Utility.map(filtered, 200, 800, 30, 150));

      // Clamp position
      if (pos < 30) pos = 30;
      if (pos > 150) pos = 150;

      // Only move if it actually changed enough
      if (Math.abs(pos - lastServoPos) >= 2) {
        Servo.setPosition(d1, pos);
        lastServoPos = pos;
      }
    }
  }

  sleep(50);
}

Add ServoSpeed too

If you want the servo itself to move more gracefully, set its speed as well:

Servo.setSpeed(d1, 5);

You can do that once in an initialization script or at project start.

A moderate value like 4-6 is usually a good starting point.

Reducing octave jumps

Those ~220 Hz / ~880 Hz jumps are harmonic-lock issues. To reduce them:

Option A: constrain the expected octave

If you know the note should be around 440 Hz, only accept values near that range.

Example logic:

• if last stable frequency was around 440
• ignore values below ~330 or above ~550 unless they persist

Option B: compare to last good value

If the new frequency is about:

• half of the last value, or
• double the last value

then reject it unless it stays there for several samples.

Option C: use a stronger fundamental source

A piano can be tricky because the overtone content is strong. A pure sine tone is much easier for the detector than piano. Your phone sine app is the better test source.

Practical tuning tips

Try this progression:

1. Start with a sine tone
2. Set Frequency Detector to a narrower range, like 380-520 Hz
3. Add script-side smoothing
4. Add deadband of 5-10 Hz
5. Set ServoSpeed to 4-6
6. Increase the script update interval to 50-100 ms

That usually gives a much calmer servo response.

Best ARC setup recommendation

For a stable pitch-following servo:

• Use Frequency Detector only to detect pitch
• Use a JavaScript loop to filter the detected frequency
• Then call Servo.setPosition(d1, pos)
• Optionally set Servo.setSpeed(d1, 4-6)

That’s generally better than relying on direct skill-to-servo mapping when you need smooth behavior.

If you want, I can help you build one of these:

1. A simple low-pass filter script
2. A median filter to suppress octave jumps
3. A full pitch-tracking script with deadband + octave rejection + servo smoothing

If you’d like, I can write a version specifically for your D1 servo and your 200-800 Hz range.