Tiny Yolo2 Tracking Filter And Jitter

Yes - the better approach in ARC is to keep the camera/tracking pipeline clean and do the class filtering/persistence in script, rather than letting servo tracking react to every transient detection.

What’s happening

With Tiny Yolo2, detections can legitimately switch between nearby classes frame-to-frame, especially when multiple objects are in view or confidence is near the threshold. If Camera Device servo tracking is enabled, it will respond immediately to whatever the active tracked object is before your On Tracking Start script gets a chance to filter it.

So your observation is correct: filtering in the script alone does not prevent the built-in servo tracking from twitching first.

Recommended setup

Option 1 - Best practice: disable built-in servo tracking and use your own "locked target" script

This is the most stable solution for what you want.

• Disable servo Tracking in Camera Device
• Keep Tiny Yolo2 active
• In a Script skill or Camera Device scripts, only accept:
  • bottle
  • and only after it has been seen for several consecutive frames
• Keep that target "locked" for a short time even if one frame drops out

This gives you:

• class filtering before motion
• persistence/hysteresis
• smoother servo behavior
• no start/stop thrash

Why this is the right way

ARC’s camera tracking is designed for detection, but "track only this class with lockout/persistence" is better handled by a custom script because it lets you define robot behavior exactly.

If you want that feature as a reusable control, you could even build a custom robot skill later: https://synthiam.com/Support/Create-Robot-Skill/Overview

Simple smoothing pattern in JavaScript

Use this pattern with:

• Camera Device + Tiny Yolo2
• servo tracking disabled
• a Script skill that runs on a timer or from a tracking event

The idea:

• only accept bottle
• require it to appear for N frames
• hold the target for a short timeout
• only nudge the servo in small steps

var lastSeenMs = 0;
var lockMs = 500;
var minConsecutive = 3;
var seenCount = 0;
var targetName = "bottle";
var centerDeadband = 20; // pixels
var step = 2; // servo degrees per update
var panPort = d12;

var currentName = getVar("$CameraObjectName", "");
var isTracking = getVar("$CameraIsTracking", "0") == "1";

if (isTracking && currentName == targetName) {
  seenCount += 1;
  lastSeenMs = new Date().getTime();
} else {
  // keep lock briefly even if detection flickers
  if ((new Date().getTime() - lastSeenMs) > lockMs) {
    seenCount = 0;
  }
}

if (seenCount < minConsecutive) {
  return;
}

var cx = parseInt(getVar("$CameraObjectCenterX", "0"));
var camW = parseInt(getVar("$CameraResolutionWidth", "320"));
var centerX = camW / 2;
var error = cx - centerX;

if (Math.abs(error) <= centerDeadband) {
  return;
}

if (error > 0) {
  Servo.increment(panPort, step);
} else {
  Servo.decrement(panPort, step);
}

Notes

• Servo.increment() / Servo.decrement() are a good fit for small corrections.
• The deadband prevents constant micro-correction.
• The lock timeout prevents twitching when YOLO briefly misses the object.

Even better: use a state-based tracker

If your goal is "follow the bottle until I lose it for a bit," then use a simple state machine:

• SEARCHING: ignore everything except bottle
• LOCKED: continue following bottle even if one or two frames miss it
• LOST: if gone too long, stop moving and return to searching

That’s more stable than reacting directly to every frame.

About the built-in filters

From what you described:

• Tiny Yolo2 does not give you a clean "only detect class X before tracking" switch that prevents the camera/servo pipeline from reacting first.
• Camera Device tracking scripts can filter afterward, but by then servo tracking may already have acted.
• So custom smoothing is the recommended approach.

Important detail

If you do keep built-in servo tracking on, it will always be more "reactive" than "stable." That is expected. For object-following behavior, especially with a single target like bottle, scripting is the proven route.

Suggested ARC workflow

1. Camera Device
   • 320x240
   • Tiny Yolo2 active
   • Servo Tracking OFF
2. Script skill
   • poll $CameraObjectName, $CameraObjectCenterX, $CameraIsTracking
   • only act on "bottle"
   • require N consecutive frames
   • hold lock for 300-700 ms
   • nudge the pan servo in small increments
3. Tune:
   • deadband
   • hold time
   • step size

Follow-up

If you want, I can write you a clean ARC JavaScript script that implements:

• bottle-only tracking
• consecutive-frame confirmation
• lock timeout
• servo smoothing
• optional stop behavior when the bottle is lost

Also, what’s your bigger goal overall - follow a bottle, pick it up, or just keep it centered in view? That will change the best control strategy.