Fixing Bearing Calc And Servo Sweep

Absolutely - thanks for clarifying. You’re right: in your model, ir <= reflectorThreshold is the edge capture condition, not the trigger to start the sweep. That means the scan should record the first low sample as negInit / posInit, continue through the target, then record the next low sample as negFinal / posFinal.

Below is a cleaner Rev24 that follows that concept and uses a true edge-tracking state machine.

Rev24 - ARC JavaScript true edge-tracking scanner

var servoPort = d17;
var irPort = ADC2;

var desiredBearing = 90;
var actualBearing = 90;

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 lastPublishedBearing = -1;
var lastValidBearing = -1;

var reflectorThreshold = 15;
var servoStep = 1;
var scanDelayMs = 20;
var settleDelayMs = 10;

var scanState = "SCAN_NEG_INIT";

// Used for threshold gating
var lowCount = 0;
var lowCountRequired = 2;

// Track which side is currently being scanned
var sweepDirection = "NEG";

print("IR tracker started. desiredBearing: " + desiredBearing);

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

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

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

function publishBearing(newBearing) {
  actualBearing = Math.round(newBearing);
  lastValidBearing = actualBearing;

  if (actualBearing != lastPublishedBearing) {
    lastPublishedBearing = actualBearing;
    desiredBearing = actualBearing;
    setVar("$actualBearing", actualBearing);
    setVar("$desiredBearing", desiredBearing);
    print("actualBearing: " + actualBearing + " desiredBearing: " + desiredBearing);
  }
}

function updateBearingFromEdges() {
  var candidate = -1;

  // Valid pair combinations based on your edge model.
  if (negInit >= 0 && posInit >= 0) {
    candidate = (negInit + posInit) / 2;
  }
  else if (negFinal >= 0 && posFinal >= 0) {
    candidate = (negFinal + posFinal) / 2;
  }
  else if (negInit >= 0 && posFinal >= 0) {
    candidate = (negInit + posFinal) / 2;
  }
  else if (negFinal >= 0 && posInit >= 0) {
    candidate = (negFinal + posInit) / 2;
  }

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

function checkObstructionTotals() {
  if (negObsTot >= negObsMax || posObsTot >= posObsMax) {
    setVar("$sendStopNow", 1);
    return true;
  }
  return false;
}

function resetPosScan() {
  posInit = -1;
  posFinal = -1;
  posObsTot = 0;
  lowCount = 0;
  setVar("$posIRTot", posObsTot);
}

function resetNegScan() {
  negInit = -1;
  negFinal = -1;
  negObsTot = 0;
  lowCount = 0;
  setVar("$negIRTot", negObsTot);
}

function stepServoNeg() {
  var current = readServo();
  if (current > 0) {
    Servo.decrement(servoPort, servoStep, 0);
  }
}

function stepServoPos() {
  var current = readServo();
  if (current < 180) {
    Servo.increment(servoPort, servoStep, 0);
  }
}

function scanStep() {
  var ir = readIR();

  if (sweepDirection == "NEG") {
    negObsTot += ir;
    setVar("$negIRTot", negObsTot);

    if (ir <= reflectorThreshold) {
      lowCount++;
    } else {
      lowCount = 0;
    }

    // First low capture on NEG sweep
    if (scanState == "SCAN_NEG_INIT" && lowCount >= lowCountRequired) {
      negInit = readServo();
      print("negInit: " + negInit);
      setVar("$negInit", negInit);

      scanState = "SCAN_NEG_FINAL";
      setVar("$scanState", scanState);
    }
    // Second low capture on NEG sweep completes the NEG edge set
    else if (scanState == "SCAN_NEG_FINAL" && lowCount >= lowCountRequired) {
      negFinal = readServo();
      print("negFinal: " + negFinal);
      setVar("$negFinal", negFinal);

      updateBearingFromEdges();

      resetPosScan();
      sweepDirection = "POS";
      scanState = "SCAN_POS_INIT";
      setVar("$scanState", scanState);

      sleep(settleDelayMs);
    }

    stepServoNeg();
    sleep(scanDelayMs);
  }
  else {
    posObsTot += ir;
    setVar("$posIRTot", posObsTot);

    if (ir <= reflectorThreshold) {
      lowCount++;
    } else {
      lowCount = 0;
    }

    // First low capture on POS sweep
    if (scanState == "SCAN_POS_INIT" && lowCount >= lowCountRequired) {
      posInit = readServo();
      print("posInit: " + posInit);
      setVar("$posInit", posInit);

      scanState = "SCAN_POS_FINAL";
      setVar("$scanState", scanState);
    }
    // Second low capture on POS sweep completes the POS edge set
    else if (scanState == "SCAN_POS_FINAL" && lowCount >= lowCountRequired) {
      posFinal = readServo();
      print("posFinal: " + posFinal);
      setVar("$posFinal", posFinal);

      updateBearingFromEdges();

      resetNegScan();
      sweepDirection = "NEG";
      scanState = "SCAN_NEG_INIT";
      setVar("$scanState", scanState);

      sleep(settleDelayMs);
    }

    stepServoPos();
    sleep(scanDelayMs);
  }
}

while (true) {
  if (checkObstructionTotals()) {
    print("Stopping: obstruction totals exceeded limit.");
    break;
  }

  scanStep();
}

How this detects rising / peak / falling edge

Here’s the idea in plain language:

• Rising edge: the IR value changes from above the threshold to at or below the threshold
• Peak / center: the scan passes through the reflector region; the script uses the two low edge captures to estimate the middle
• Falling edge: the IR value changes back from low to high, indicating the reflector region is ending

In your implementation, the important part is not the literal "peak" of the sensor value - it’s the center estimate formed between the two captured edge positions.

Why this version is better

1. State-based gating

Each state only fires once:

• SCAN_NEG_INIT
• SCAN_NEG_FINAL
• SCAN_POS_INIT
• SCAN_POS_FINAL

That prevents repeated captures while the IR remains low across multiple loop cycles.

2. Threshold debounce

lowCountRequired makes the script wait for a couple of consecutive low readings before confirming an edge.

That helps avoid false triggers from noisy IR readings.

3. Continuous sweep

The servo keeps moving:

• NEG sweep uses Servo.decrement()
• POS sweep uses Servo.increment()

So it won’t stall at the center unless the servo physically reaches its limit.

4. Bearing only after valid edge pairs

updateBearingFromEdges() runs after negFinal or posFinal is captured, which matches your request.

One note on the edge math

You mentioned a true edge-tracking scanner, so this version treats the low-threshold region as the reflector band and uses:

• first low sample = init edge
• second low sample = final edge

If you want, I can take this one step further and make the bearing logic explicitly use only the matching pair for each sweep, rather than allowing fallback combinations.

That would make the scan stricter and easier to reason about.

If you’d like, I can now write a Rev25 that:

• adds comments directly above each state
• removes the fallback pair combinations
• publishes only when the exact expected pair is confirmed
• adds optional logging for debugging the threshold transitions

@Athena. Thank you for your continued support. The logic for function ' updateBearingFromEdges(edgeName) ':

• At negInit actualBearing = (negInit + posInit) / 2
• At negFinal actualBearing = (negFinal + posFinal) / 2
• At posInit actualBearing = (posInit + negInit) / 2
• At posFinal actualBearing = (posFinal + negFinal) / 2

The logic for function ' scanStep() ':

1. Under 'sweep direction NEG', negInit should be identified as ir <= reflectorThreshold.
2. After identifying 'negInit', updateBearingFromEdges should be called.
3. Under 'sweep direction NEG, negFinal should be identified as ir > reflectorThreshold.
4. After identifying 'negFinal', updateBearingFromEdges should be called.
5. Under 'sweep direction POS', posInit should be identified as ir <= reflectorThreshold.
6. After identifying 'posInit', updateBearingFromEdges should be called.
7. Under 'sweep direction POS', posFinal should be identified as ir > reflectorThreshold.
8. After identifying 'posFinal', updateBearingFromEdges should be called.

The script below follows the logic stated above. Please review the following script for efficiency, accuracy, and simplicity. REV 25

var servoPort = d17;
var irPort = ADC2;

var desiredBearing = 90;
var actualBearing = 90;

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 lastPublishedBearing = -1;

var reflectorThreshold = 15;
var servoStep = 1;
var scanDelayMs = 20;
var settleDelayMs = 10;

var sweepDirection = "NEG";
var state = "MOVE";

print("IR tracker started. desiredBearing: " + desiredBearing);

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

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

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

function publishBearing(newBearing) {
  actualBearing = Math.round(newBearing);

  if (actualBearing != lastPublishedBearing) {
    lastPublishedBearing = actualBearing;
    desiredBearing = actualBearing;
    setVar("$actualBearing", actualBearing);
    setVar("$desiredBearing", desiredBearing);
    print("actualBearing: " + actualBearing + " desiredBearing: " + desiredBearing);
  }
}

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

  // Use the edge pair that corresponds to the current scan event.
  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 checkObstructionTotals() {
  if (negObsTot >= negObsMax || posObsTot >= posObsMax) {
    setVar("$sendStopNow", 1);
    return true;
  }
  return false;
}

function moveServoForSweep() {
  var current = readServo();

  if (sweepDirection == "NEG") {
    if (current > 0) {
      Servo.decrement(servoPort, servoStep, 0);
    } else {
      sweepDirection = "POS";
    }
  }
  else {
    if (current < 180) {
      Servo.increment(servoPort, servoStep, 0);
    } else {
      sweepDirection = "NEG";
    }
  }
}

function scanStep() {
  var ir = readIR();

  if (sweepDirection == "NEG") {
    negObsTot += ir;
    setVar("$negIRTot", negObsTot);

    if (ir <= reflectorThreshold && negInit < 0) {
      negInit = readServo();
     // print("negInit: " + negInit);
      updateBearingFromEdges("negInit");
    }

    if (ir > reflectorThreshold && negInit >= 0 && negFinal < 0) {
      negFinal = readServo();
    //  print("negFinal: " + negFinal);
      updateBearingFromEdges("negFinal");

      // Prepare for next POS scan
      posInit = -1;
      posFinal = -1;
      posObsTot = 0;
      setVar("$posIRTot", posObsTot);
             Servo.setPosition(servoPort,negInit);
              sleep(scanDelayMs);

      sweepDirection = "POS";
    }
  }
  else {
    posObsTot += ir;
    setVar("$posIRTot", posObsTot);

    if (ir <= reflectorThreshold && posInit < 0) {
      posInit = readServo();
    //  print("posInit: " + posInit);
      updateBearingFromEdges("posInit");
    }

    if (ir > reflectorThreshold && posInit >= 0 && posFinal < 0) {
      posFinal = readServo();
    //  print("posFinal: " + posFinal);
      updateBearingFromEdges("posFinal");

      // Prepare for next NEG scan
      negInit = -1;
      negFinal = -1;
      negObsTot = 0;
      setVar("$negIRTot", negObsTot);
           Servo.setPosition(servoPort,posInit);
              sleep(scanDelayMs);

      sweepDirection = "NEG";
    }
  }

  if (checkObstructionTotals()) {
    return;
  }

  moveServoForSweep();
  sleep(scanDelayMs);
}

while (true) {
  scanStep();
}

Can you please add a simple way to prevent a runaway servo for NEG sweep if negInit is never found or for a POS sweep if posInit is never found?

Criteria for the runaway servo prevention:

1. For NEG sweep, allow 20 degrees past desiredBearing(90) before it aborts the search.
2. Servo.setPosition(servoPort,desiredBearing) .
3. For POS sweep, allow 20 degrees past desiredBearing(90) before it aborts the search.
4. Servo.setPosition(servoPort,desiredBearing) .
5. setVar("$sendStopNow", 1).

Thank you. Jack

Yes - that’s a good safety addition.

Your current Rev25 logic is close, but the runaway protection should be state-based, not just based on time. That means if the script is scanning NEG or POS and never finds the threshold capture point, it should bail out once the servo exceeds a safe range beyond desiredBearing.

What to add

For your criteria, the simplest approach is:

• Define a maxSweepOffset = 20
• Track a timeout/safety abort when:
  • NEG sweep goes below desiredBearing - 20
  • POS sweep goes above desiredBearing + 20
• On abort:
  • Servo.setPosition(servoPort, desiredBearing)
  • setVar("$sendStopNow", 1)

Recommended safety helper

Add this helper:

var maxSweepOffset = 20;

function abortSweep(reason) {
  print("Abort sweep: " + reason);
  Servo.setPosition(servoPort, desiredBearing);
  setVar("$sendStopNow", 1);
}

Add bounds for NEG and POS

Add these variables near the top:

var negAbortLimit = desiredBearing - maxSweepOffset;
var posAbortLimit = desiredBearing + maxSweepOffset;

If you want to recalculate them anytime desiredBearing changes, wrap them in a function:

function updateSweepLimits() {
  negAbortLimit = desiredBearing - maxSweepOffset;
  posAbortLimit = desiredBearing + maxSweepOffset;
}

Call that once at startup and again whenever desiredBearing is changed.

Updated moveServoForSweep()

Here’s the safer version:

function moveServoForSweep() {
  var current = readServo();

  if (sweepDirection == "NEG") {
    if (current <= negAbortLimit) {
      abortSweep("NEG sweep exceeded safe limit");
      return;
    }

    if (current > 0) {
      Servo.decrement(servoPort, servoStep, 0);
    } else {
      sweepDirection = "POS";
    }
  } else {
    if (current >= posAbortLimit) {
      abortSweep("POS sweep exceeded safe limit");
      return;
    }

    if (current < 180) {
      Servo.increment(servoPort, servoStep, 0);
    } else {
      sweepDirection = "NEG";
    }
  }
}

A small but important note

Your existing code uses:

Servo.setPosition(servoPort, posInit);

That is fine only if you intentionally want to jump back to the initial edge position. For a continuous sweep, Servo.increment() / Servo.decrement() is usually cleaner and less likely to create jumps.

Best practice for your scan logic

You’ll want your scanStep() to:

1. Read IR
2. Detect threshold events
3. If no event yet, keep moving servo
4. Before each movement, check abort limits
5. If abort limit is hit, stop and return to desiredBearing

One more refinement

Because desiredBearing is being updated by publishBearing(), the abort limits should be recalculated after a new bearing is published.

Example:

function publishBearing(newBearing) {
  actualBearing = Math.round(newBearing);

  if (actualBearing != lastPublishedBearing) {
    lastPublishedBearing = actualBearing;
    desiredBearing = actualBearing;
    updateSweepLimits();

    setVar("$actualBearing", actualBearing);
    setVar("$desiredBearing", desiredBearing);
    print("actualBearing: " + actualBearing + " desiredBearing: " + desiredBearing);
  }
}

If you want, I can do this next

I can rewrite your full Rev25 into a cleaner Rev26 with:

• the runaway servo protection added
• the edge logic preserved
• safer NEG/POS sweep limits
• simplified state handling
• comments on each section for easier maintenance

If you’d like, I can produce the full updated code block now.

@Athena. Thank you.

Can you rewrite the full Rev25 into a cleaner Rev26 with:

• the runaway servo protection added
• the edge logic preserved
• safer NEG/POS sweep limits
• simplified state handling.
• comments on each section for easier maintenance.

Thank you. 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

@Athena. Thank you. Jack