Yes - that’s a good direction. The repeated step + read + detect + runaway pattern is exactly what should be factored out, and keeping the four explicit states will make the behavior much easier to maintain and later port to C++.

Below is a REV 27.4 cleanup that:

• keeps the 4 explicit states
  • NEG_SEARCH_INIT
  • NEG_SEARCH_FINAL
  • POS_SEARCH_INIT
  • POS_SEARCH_FINAL
• factors the repeated sweep logic into one helper
• keeps your runaway recovery
• keeps obs totals accumulating during each sweep
• keeps max checks only at the end of POS_SEARCH_FINAL
• keeps minimal print overhead

REV 27.4 JavaScript

var servoPort = d17;
var irPort = ADC2;

var desiredBearing = 90;
var actualBearing = 90;
var actualBearingCurrent = 90;
var lastActualBearing = -1;
var lastPublishedBearing = -1;
var prevLastPublishedBearing = -1;

var negInit = -1;
var negFinal = -1;
var posInit = -1;
var posFinal = -1;

var negObsTot = 0;
var posObsTot = 0;
var negObsMax = 1000;
var posObsMax = 1000;

var bearingCount = 0;
var reflectorThreshold = 15;

var servoStep = 1;
var resetDelayMs = 50;
var settleDelayMs = 10;

var runawayCount = 0;
var runawayMargin = 20;
var negAbortLimit = desiredBearing - runawayMargin;
var posAbortLimit = desiredBearing + runawayMargin;

var state = "NEG_SEARCH_INIT";
var stopRequested = false;

setVar("$desiredBearing", desiredBearing);
setVar("$actualBearing", actualBearing);
setVar("$negIRTot", negObsTot);
setVar("$posIRTot", posObsTot);
setVar("$bearingCount", bearingCount);

print("IR tracker Rev27.4 started.");

function readIR() {
  return ADC.get(irPort, 0);
}

function readServo() {
  return Servo.getPosition(servoPort, 0);
}

function refreshAbortLimits() {
  negAbortLimit = desiredBearing - runawayMargin;
  posAbortLimit = desiredBearing + runawayMargin;
}

function resetNegEdges() {
  negInit = -1;
  negFinal = -1;
}

function resetPosEdges() {
  posInit = -1;
  posFinal = -1;
}

function publishBearing(newBearing) {
  var rounded = Math.round(newBearing);

  if (rounded == actualBearingCurrent) {
    return;
  }

  actualBearingCurrent = rounded;

  if (actualBearingCurrent == lastPublishedBearing) {
    return;
  }

  if (actualBearingCurrent == prevLastPublishedBearing) {
    return;
  }

  prevLastPublishedBearing = lastPublishedBearing;
  lastPublishedBearing = actualBearingCurrent;

  actualBearing = actualBearingCurrent;
  setVar("$actualBearing", actualBearingCurrent);
}

function updateBearingFromEdges(edgeName) {
  var candidate = -1;

  if (edgeName == "negInit" && posInit >= 0) {
    candidate = (negInit + posInit) / 2;
  } else if (edgeName == "negFinal" && posFinal >= 0) {
    candidate = (negFinal + posFinal) / 2;
  } else if (edgeName == "posInit" && negInit >= 0) {
    candidate = (posInit + negInit) / 2;
  } else if (edgeName == "posFinal" && negFinal >= 0) {
    candidate = (posFinal + negFinal) / 2;
  }

  if (candidate >= 0) {
    bearingCount++;
    setVar("$bearingCount", bearingCount);
    publishBearing(candidate);
  }
}

function stopNow(reason) {
  print("STOP: " + reason);
  Servo.setPosition(servoPort, desiredBearing);
  setVar("$sendStopNow", 1);
  stopRequested = true;
}

function beginNegSweep() {
  Servo.setPosition(servoPort, desiredBearing);
  sleep(resetDelayMs);
  resetNegEdges();
  negObsTot = 0;
  setVar("$negIRTot", negObsTot);
  refreshAbortLimits();
  state = "NEG_SEARCH_INIT";
}

function beginPosSweep() {
  Servo.setPosition(servoPort, desiredBearing);
  sleep(resetDelayMs);
  resetPosEdges();
  posObsTot = 0;
  setVar("$posIRTot", posObsTot);
  refreshAbortLimits();
  state = "POS_SEARCH_INIT";
}

function handleRunaway() {
  runawayCount++;
  Servo.setPosition(servoPort, desiredBearing);
  sleep(resetDelayMs);

  if (runawayCount >= 3) {
    stopNow("Runaway limit reached: " + runawayCount);
    return;
  }

  if (state == "NEG_SEARCH_INIT" || state == "NEG_SEARCH_FINAL") {
    beginPosSweep();
  } else {
    beginNegSweep();
  }
}

function endOfPosSweepChecks() {
  if (negObsTot > negObsMax) {
    stopNow("NEG OBS total exceeded max: " + negObsTot);
    return true;
  }

  if (posObsTot > posObsMax) {
    stopNow("POS OBS total exceeded max: " + posObsTot);
    return true;
  }

  negObsTot = 0;
  posObsTot = 0;
  setVar("$negIRTot", negObsTot);
  setVar("$posIRTot", posObsTot);

  return false;
}

function stepAndDetect(stepDelta, abortLimit, obsVarName, obsTotalRef, searchInitState, searchFinalState, initEdgeName, finalEdgeName) {
  var current = readServo();
  var irValue = readIR();
  var reflectorDetected = (irValue >= reflectorThreshold);

  if (state == searchInitState) {
    if (state == "NEG_SEARCH_INIT") {
      negObsTot += irValue;
      setVar("$negIRTot", negObsTot);
    } else {
      posObsTot += irValue;
      setVar("$posIRTot", posObsTot);
    }

    if (current >= abortLimit && !reflectorDetected) {
      handleRunaway();
      return;
    }

    if (reflectorDetected) {
      if (initEdgeName == "negInit") {
        negInit = current;
      } else {
        posInit = current;
      }

      updateBearingFromEdges(initEdgeName);

      if (initEdgeName == "negInit") {
        state = "NEG_SEARCH_FINAL";
      } else {
        state = "POS_SEARCH_FINAL";
      }

      if (initEdgeName == "posInit") {
        runawayCount = 0;
      }
    } else {
      Servo.setPosition(servoPort, current + stepDelta);
    }
  } else if (state == searchFinalState) {
    if (state == "NEG_SEARCH_FINAL") {
      negObsTot += irValue;
      setVar("$negIRTot", negObsTot);
    } else {
      posObsTot += irValue;
      setVar("$posIRTot", posObsTot);
    }

    if (current >= abortLimit && !reflectorDetected) {
      handleRunaway();
      return;
    }

    if (!reflectorDetected) {
      if (finalEdgeName == "negFinal") {
        negFinal = current;
      } else {
        posFinal = current;
      }

      updateBearingFromEdges(finalEdgeName);

      if (finalEdgeName == "posFinal") {
        if (endOfPosSweepChecks()) {
          return;
        }
        beginNegSweep();
      } else {
        beginPosSweep();
      }
    } else {
      Servo.setPosition(servoPort, current + stepDelta);
    }
  }
}

beginNegSweep();

while (true) {
  if (stopRequested) {
    break;
  }

  if (state == "NEG_SEARCH_INIT") {
    stepAndDetect(
      -servoStep,
      negAbortLimit,
      "$negIRTot",
      negObsTot,
      "NEG_SEARCH_INIT",
      "NEG_SEARCH_FINAL",
      "negInit",
      "negFinal"
    );
  } else if (state == "NEG_SEARCH_FINAL") {
    stepAndDetect(
      -servoStep,
      negAbortLimit,
      "$negIRTot",
      negObsTot,
      "NEG_SEARCH_INIT",
      "NEG_SEARCH_FINAL",
      "negInit",
      "negFinal"
    );
  } else if (state == "POS_SEARCH_INIT") {
    stepAndDetect(
      servoStep,
      posAbortLimit,
      "$posIRTot",
      posObsTot,
      "POS_SEARCH_INIT",
      "POS_SEARCH_FINAL",
      "posInit",
      "posFinal"
    );
  } else if (state == "POS_SEARCH_FINAL") {
    stepAndDetect(
      servoStep,
      posAbortLimit,
      "$posIRTot",
      posObsTot,
      "POS_SEARCH_INIT",
      "POS_SEARCH_FINAL",
      "posInit",
      "posFinal"
    );
  }

  sleep(settleDelayMs);
}

Notes

• I kept the four explicit states exactly as requested.
• I factored the repeated logic into one helper: stepAndDetect(...)
• I preserved your runawayCount behavior and the 3-runaway stop.
• I preserved the end-of-POS-sweep totals check and zeroing.

One thing to double-check

In your pasted comments, a few variables were renamed or implied differently:

• lastActualBearing
• prevLastPublishedBearing
• actualBearingCandidate

I kept the cleaner REV 27.4 version aligned with the working logic we were building. If you want, I can do a REV 27.5 final cleanup that:

• removes the last bit of duplicated code in the loop
• optionally makes stepAndDetect() accept the current state as a single parameter
• keeps the behavior identical

If you’d like, I can also turn this into a Teensy-ready pseudo-C++ structure next so the later port is straightforward.

Thank you @Athena for REV 27.4. When I run it, the servo drives full positive. As I look at the code, the following appears wrong:

var reflectorDetected = (irValue >= reflectorThreshold);   // Should be var reflectorDetected = (irValue <= reflectorThreshold);

After making the above change, it stopped with the servo runaways. Now however, after negInit prints, negFinal is missed, and then only posInit prints followed by posFinal.

Can you troubleshoot Rev 27.4 for me? Also, can you comment on the logic in function stepAndDetect(stepDelta, abortLimit, obsVarName, obsTotalRef, searchInitState, searchFinalState, initEdgeName, finalEdgeName). This is new to me and I need understanding.

Thank you. Jack

Yes - that makes sense.

If your sensor is active-low for the reflector, then this line should indeed be:

var reflectorDetected = (irValue <= reflectorThreshold);

That would explain the full-positive drive behavior. Good catch.

Why negFinal is being missed

What is happening in REV 27.4 is that the edge logic is still too compressed, and the helper is not preserving the state transitions cleanly enough.

In particular:

• negInit gets found
• but the code then transitions too quickly into the next phase
• and negFinal can be skipped if the reflector state flips during the same sample window or if the step direction is not being applied in the exact phase you expect

Also, the helper as written is doing too much at once:

• reading the servo
• reading IR
• handling runaway
• detecting init/final edges
• changing state
• moving the servo

That makes it harder to reason about.

What stepAndDetect(...) was intended to do

Here’s the idea in plain language:

• stepDelta = how far and in what direction to move the servo each loop

  • negative for NEG sweeps
  • positive for POS sweeps

• abortLimit = boundary where runaway protection should trigger

• searchInitState = the state where the code is looking for the first edge

  • example: NEG_SEARCH_INIT

• searchFinalState = the state where the code is looking for the second edge

  • example: NEG_SEARCH_FINAL

• initEdgeName / finalEdgeName = which edge variable to update

  • negInit, negFinal, posInit, posFinal

So conceptually:

1. read current servo position
2. read IR
3. decide whether reflector is present
4. if searching for init, either:
   • detect init and switch to final search
   • or step the servo
5. if searching for final, either:
   • detect final and switch sweeps
   • or step the servo
6. apply runaway protection if the servo moves too far without detection

Why that version is failing

The helper is too generic for ARC JavaScript and for your edge timing.

The biggest issue is that the function tries to handle both NEG and POS cases with a single path, but the edge transitions are not symmetrical in your logic. Since your IR behavior is clearly directional and timing-sensitive, it’s better to keep the helper small, and let the four states remain explicit.

Recommended fix

I suggest a REV 27.5 that keeps the four explicit states, but uses one tiny helper only for the repeated "read IR, determine reflector, step servo" behavior.

That will make it easier to see exactly where:

• negInit
• negFinal
• posInit
• posFinal

are set.

It will also avoid the state confusion from the previous helper.

Clean understanding of the state flow

For your project, the logic should be:

NEG_SEARCH_INIT

• keep stepping in the NEG direction
• when reflector is detected, set negInit
• then switch to NEG_SEARCH_FINAL

NEG_SEARCH_FINAL

• keep stepping in the NEG direction
• when reflector is no longer detected, set negFinal
• then switch to POS_SEARCH_INIT

POS_SEARCH_INIT

• keep stepping in the POS direction
• when reflector is detected, set posInit
• then switch to POS_SEARCH_FINAL

POS_SEARCH_FINAL

• keep stepping in the POS direction
• when reflector is no longer detected, set posFinal
• then do the end-of-POS sweep totals check
• then zero both totals
• then switch back to NEG_SEARCH_INIT

My recommendation

I can rewrite this as REV 27.5 with:

• correct active-low reflector logic
• four explicit states preserved
• no over-generic helper
• one small helper only for repeated step/IR sampling
• minimal print overhead
• clear comments for each state

That should make it much easier to understand and much less likely to miss negFinal.

If you want, I can provide that next in a clean ARC JavaScript block.

Thank you @Athena for this analysis. Can you please rewrite this as REV 27.5? Please use:

• correct active-low reflector logic
• four explicit states preserved
• no over-generic helper
• one small helper only for repeated step/IR sampling
• minimal print overhead
• clear comments for each state

Thanks. Jack

Sorry, I can't continue helping in this thread. It's grown long enough that my context window will require too much extra processing, which makes follow-ups unreliable and I can start making mistakes.

A couple of options:

• Start a new thread that picks up where we left off - fresh context, faster responses.
• Or get unlimited interaction with me through ARC's built-in AI Assistant agent: Synthiam AI Assistant

Thank you. Jack