Kinect Control Jitter On Arduino Uno

Yes - the cleanest way to tame this in ARC is to decouple Kinect Body Control from the physical servos and add a small filter layer in between.

What you’re describing sounds like a mix of:

• Kinect tracking noise near a "still" pose
• high update frequency from the body skill
• camera load from Picture-in-Picture increasing CPU usage
• servo chatter because the skill keeps sending tiny position changes

Recommended ARC architecture

Instead of letting Kinect Body Control drive D9/D10/D5/D6 directly:

1. Kinect Body Control virtual servo ports
   • Example: v0, v1, v2, v3
2. A script reads the virtual servos
3. The script applies:
   • deadband
   • rate limiting
   • optionally smoothing / step size control
4. The script writes the filtered positions to the real Uno ports

This gives you a "buffer" layer where tiny motion changes get ignored.

Why virtual servos help

Virtual servo ports are great for exactly this kind of problem because they let ARC hold the tracked values without immediately driving hardware.

You can map Kinect joints to:

• v0 = head yaw
• v1 = head pitch
• v2 = shoulder
• v3 = elbow

Then only your script decides when a physical servo should move.

Simple deadband + rate limiter example

Here’s a JavaScript example you can adapt in ARC:

var lastHeadYaw = -1
var lastHeadPitch = -1
var lastShoulder = -1
var lastElbow = -1

var deadband = 3       // ignore changes smaller than 3 degrees
var minStep = 2        // minimum change before sending a new servo command
var updateMs = 40      // rate limit to about 25 updates/sec

while (true) {
  var headYaw = Servo.getPosition(v0)
  var headPitch = Servo.getPosition(v1)
  var shoulder = Servo.getPosition(v2)
  var elbow = Servo.getPosition(v3)

  if (lastHeadYaw == -1 || Math.abs(headYaw - lastHeadYaw) >= minStep) {
    if (Math.abs(headYaw - lastHeadYaw) >= deadband || lastHeadYaw == -1) {
      Servo.setPosition(d9, headYaw)
      lastHeadYaw = headYaw
    }
  }

  if (lastHeadPitch == -1 || Math.abs(headPitch - lastHeadPitch) >= minStep) {
    if (Math.abs(headPitch - lastHeadPitch) >= deadband || lastHeadPitch == -1) {
      Servo.setPosition(d10, headPitch)
      lastHeadPitch = headPitch
    }
  }

  if (lastShoulder == -1 || Math.abs(shoulder - lastShoulder) >= minStep) {
    if (Math.abs(shoulder - lastShoulder) >= deadband || lastShoulder == -1) {
      Servo.setPosition(d5, shoulder)
      lastShoulder = shoulder
    }
  }

  if (lastElbow == -1 || Math.abs(elbow - lastElbow) >= minStep) {
    if (Math.abs(elbow - lastElbow) >= deadband || lastElbow == -1) {
      Servo.setPosition(d6, elbow)
      lastElbow = elbow
    }
  }

  sleep(updateMs)
}

Better version: move in small steps toward the target

This usually feels smoother than jumping directly to the target:

function moveToward(current, target, maxStep) {
  if (Math.abs(target - current) <= maxStep) {
    return target
  }
  if (target > current) {
    return current + maxStep
  }
  return current - maxStep
}

var currentYaw = 90
var currentPitch = 90

while (true) {
  var targetYaw = Servo.getPosition(v0)
  var targetPitch = Servo.getPosition(v1)

  if (Math.abs(targetYaw - currentYaw) >= 3) {
    currentYaw = moveToward(currentYaw, targetYaw, 2)
    Servo.setPosition(d9, currentYaw)
  }

  if (Math.abs(targetPitch - currentPitch) >= 3) {
    currentPitch = moveToward(currentPitch, targetPitch, 2)
    Servo.setPosition(d10, currentPitch)
  }

  sleep(30)
}

This creates a soft limiter that absorbs tiny Kinect fluctuations.

About Picture-in-Picture making it worse

That makes sense. PIP adds extra camera work, and if ARC is spending more CPU on video processing, Kinect tracking updates can become less stable.

A few practical suggestions:

• Keep PIP off during tuning
• If you need PIP, use:
  • lower resolution
  • lower frame rate
  • and avoid processing on the source stream if possible
• Put the Kinect tracking and servo filtering in the same ARC project, but keep the servo filter script lightweight

You may also want to check whether the Kinect skill itself has any extra smoothing or update options beyond the general smoothing slider.

Important settings tip

For servos that twitch near center, also consider:

• slower servo speed on the physical ports
• a slightly wider deadband for the head than the arms
• using less aggressive range mapping so the Kinect doesn’t move the servo through tiny changes around a narrow center region

For example:

• head yaw deadband: 4-5
• head pitch deadband: 4-5
• arm deadband: 2-3

Best practice in ARC

If you want, I’d recommend this workflow:

1. Add Kinect Body Control
2. Map joints to virtual servos
3. Add a JavaScript control script to:
   • read virtual positions
   • apply deadband
   • rate limit updates
   • optionally smooth with step motion
4. Drive D9, D10, D5, D6 from that script

This is a very common way to make motion tracking feel much more robotic and less "nervous."

If you want, I can help you build the exact ARC setup

I can write you a ready-to-paste JavaScript filter script for:

• 2 servos
• or all 4 servos
• with deadband + rate limit + smoothing
• using your exact ports: d9, d10, d5, d6

If you’d like, I can also show you where to configure the virtual servos in Kinect Body Control via the skill’s kebab menu settings.

Questions:

1. Are you currently assigning Kinect Body Control directly to the physical ports, or have you already tried virtual ports?
2. Do you want the filter to run as a separate script skill, or would you prefer a setup that uses control commands / startup script?