Smoothing Frequency Detector To Mega Servo

You’re on the right track moving the smoothing into a script. The snap-to-min/max behavior usually means the detector is occasionally outputting a bad read, and the servo is faithfully obeying it.

Short answers

1) Does Frequency Detector expose amplitude/confidence?

Usually no confidence value is exposed for gating unless the skill explicitly documents one. If the skill’s variable output is only frequency, then the safest approach is to build your own validity filter:

• ignore values outside the expected range
• reject sudden impossible jumps
• require several consecutive "good" reads before updating the servo
• hold the last valid position during dropouts

If the skill has a settings kebab menu on the top right, check whether it exposes extra options like smoothing, sensitivity, or output variables. If not, then scripting is the way to go.

2) Can you programmatically pause the skill?

If the skill supports a ControlCommand, it will be listed in that skill’s kebab menu / cheat sheet or inside the script editor’s command list.

Try this pattern from a script:

controlCommand("Frequency Detector", "SomeCommand");

But the exact command name depends on the skill. If the Frequency Detector manual does not show a pause command, then ARC cannot guess it. In that case, the script should simply ignore bad data and hold the last good servo position instead of pausing the skill.

3) Does ServoSpeed() apply to the Arduino Mega firmware?

For a standard positional servo on the Mega firmware, servo speed control may not behave like a real smoothing filter. The ARC servo command goes to the capability controller, but the hardware servo itself still moves according to the pulse changes. For an MG996R, the smoothness usually comes from:

• reducing how often you command new positions
• stepping gradually instead of jumping
• filtering the input before sending a new position

So yes, a step/hold filter in JavaScript is the right approach.

Recommended approach

Instead of sending every detected frequency straight to the servo, use:

1. range check
2. spike rejection
3. low-pass smoothing
4. rate limiting
5. hold last valid position on dropout

Here’s a more robust ARC JavaScript example:

// Tuning
var minHz = 300;
var maxHz = 1000;
var minPos = 20;
var maxPos = 160;

var maxJumpHz = 80;     // reject sudden impossible frequency jumps
var alpha = 0.15;       // smoothing factor
var lastHz = getVar("$lastHz") || 0;
var filtHz = getVar("$filtHz") || 0;
var lastPos = getVar("$lastPos") || 90;

// Read frequency
var f = parseFloat(getVar("$freqHz"));
if (isNaN(f)) {
  return;
}

// Reject out-of-range values
if (f < minHz || f > maxHz) {
  print("Ignored out-of-range frequency: " + f);
  return;
}

// Reject spikes
if (lastHz > 0 && Math.abs(f - lastHz) > maxJumpHz) {
  print("Ignored spike: " + f + " Hz");
  return;
}

// Smooth
if (filtHz === 0) {
  filtHz = f;
} else {
  filtHz = (alpha * f) + ((1 - alpha) * filtHz);
}

// Map frequency to servo position
var t = (filtHz - minHz) / (maxHz - minHz);
var pos = Math.round(minPos + t * (maxPos - minPos));

// Clamp
if (pos < minPos) pos = minPos;
if (pos > maxPos) pos = maxPos;

// Rate limit servo movement
var maxStep = 2;
if (pos > lastPos + maxStep) pos = lastPos + maxStep;
if (pos < lastPos - maxStep) pos = lastPos - maxStep;

// Send only if changed enough
if (Math.abs(pos - lastPos) >= 1) {
  Servo.setPosition(d0, pos);
  print("Freq: " + f + " Filtered: " + Math.round(filtHz) + " Pos: " + pos);
}

// Save state
setVar("$lastHz", f);
setVar("$filtHz", filtHz);
setVar("$lastPos", pos);

Why this works better

Your current script smooths the frequency, but one wild spike can still slip through and cause a jump. The extra protections above help by:

• rejecting 0 Hz / nonsense reads
• blocking sudden jumps
• only moving the servo a few degrees per update
• holding the last stable position

That combination is usually what stops chatter.

A few important ARC notes

• In ARC JavaScript, use Servo.setPosition(d0, pos), not Servo("D0", pos).
• Use the constant port d0 without quotes.
• Use print() for debug output.
• ARC’s built-in sleep(100) is fine.
• If your script is running in a loop, keep the loop timing consistent rather than writing too fast.

Best practical tuning tips

Try these values first:

• alpha = 0.10 to 0.20
• maxJumpHz = 50 to 100
• servo update only every 50-100 ms
• ignore any frequency below 300 or above 1000

Also, if the piano app produces harmonics or octave jumps, the detector may briefly lock onto a harmonic instead of the fundamental. That’s another reason to add spike rejection.

About pausing the skill

If you want, you can inspect the Frequency Detector skill’s settings kebab menu and see whether it exposes a ControlCommand list or a status variable. If it does, I can help you wire it into a script. If not, it’s usually cleaner to just keep your own last-good-value hold in JavaScript.

Best ARC workflow for this

For this kind of project, I’d recommend:

1. Frequency Detector outputs to a variable like $freqHz
2. Script reads that variable
3. Script filters it
4. Script drives the servo on d0

That gives you the most control and avoids the skill directly commanding the servo on every raw measurement.

You may also want to look at the ARC AI Assistant inside ARC for rewriting this script directly in the editor:
https://synthiam.com/Products/AI-Assistant

If you want, I can help you turn this into a full ARC script loop that continuously reads $freqHz, smooths it, and drives d0 with hysteresis and dropout hold.