Absolutely - that’s a solid plan.

Using ARC to compute scanIntervalSteps is the cleaner approach, especially if ARC is already converting all leg distances from inches to steps. That keeps the Arduino focused on motion execution, bearing correction, and scan scheduling, while ARC remains the source of truth for geometry and navigation planning.

Your scan interval math

With the numbers you gave:

• 200 steps/rev
• 1/8 microstepping
• 1:1 gearing
• 4 inch wheel diameter

Steps per revolution

200 * 8 = 1600 steps/rev

Wheel circumference

4 * PI = 12.566 inches

Steps per inch

1600 / 12.566 = ~127.32 steps/inch

24-inch scan interval

127.32 * 24 = ~3056 steps

So your ARC script can start with:

scanIntervalSteps = 3056

That should give you a very close 24-inch scan interval.

Suggested ARC-side STEPS_v1 idea

Yes, ARC can absolutely compute this and send it in WAYPOINT DATA or a dedicated packet.

A simple ARC JavaScript helper could calculate the scan interval like this:

var stepsPerRev = 200 * 8;
var wheelDiameterInches = 4;
var wheelCircumference = wheelDiameterInches * Math.PI;
var stepsPerInch = stepsPerRev / wheelCircumference;

var scanIntervalInches = 24;
var scanIntervalSteps = Math.round(stepsPerInch * scanIntervalInches);

print("scanIntervalSteps = " + scanIntervalSteps);

If you want, I can help you define the exact UART_v7 packet layout next so ARC sends this cleanly to Arduino.

Full rewritten Arduino_v7 sketch

Below is a cleaned-up version with:

• atan2() geometry
• corrected scan interval handling
• dedicated updateObstacleScanSchedule()
• cleaned-up runForwardLoop()
• average-of-four-stepper distance tracking

I also kept the framework oriented around your ARC/Arduino serial protocol.

#include <AccelStepper.h>
#include <MultiStepper.h>
#include <math.h>

static const uint8_t UART_HEADER = 0xA5; // ARC -> Arduino

static const uint8_t CMD_STOP_MOTORS      = 0x01;
static const uint8_t CMD_ACTUAL_BEARING   = 0x03;
static const uint8_t CMD_RIGHT_PIVOT      = 0x04;
static const uint8_t CMD_LEFT_PIVOT       = 0x05;
static const uint8_t CMD_WAYPOINT_DATA    = 0x06;

// Arduino -> ARC
static const uint8_t RSP_NAV_ACK          = 0x10;
static const uint8_t RSP_TOTAL_STEPS      = 0x11;
static const uint8_t RSP_DESIRED_BEARING  = 0x12;
static const uint8_t RSP_OBS_SCAN_REQUEST  = 0x13;

static const uint8_t MAX_PAYLOAD = 32;

// -------------------------
// Motor setup
// -------------------------
AccelStepper LeftFrontWheel(AccelStepper::DRIVER, 3, 6);
AccelStepper LeftBackWheel(AccelStepper::DRIVER, 2, 5);
AccelStepper RightFrontWheel(AccelStepper::DRIVER, 12, 13);
AccelStepper RightBackWheel(AccelStepper::DRIVER, 4, 7);

MultiStepper multiStepper;

// -------------------------
// Parser
// -------------------------
enum ParserState {
  WAIT_HEADER,
  WAIT_CMD,
  WAIT_LEN,
  WAIT_PAYLOAD,
  WAIT_CHECKSUM
};

ParserState parserState = WAIT_HEADER;
uint8_t currentCmd = 0;
uint8_t expectedLen = 0;
uint8_t payloadIndex = 0;
uint8_t payload[MAX_PAYLOAD];
uint8_t runningChecksum = 0;

// -------------------------
// Navigation state
// -------------------------
bool navRunning = false;
bool scanNeutralMode = false;

uint32_t totalStepsTaken = 0;
uint32_t combinedStepsDesired = 0;
uint32_t pathTotalDistance = 0;
int32_t oppositeDistance = 0;

uint32_t nextScanStep = 0;
uint32_t scanIntervalSteps = 3056; // ~24 inches based on 200 step motor, 1/8 microstepping, 4" wheel

uint8_t bearingAlignment = 0;
uint8_t trackDir = 0;

uint16_t actualBearing100 = 9000;
uint16_t desiredBearing100 = 9000;
uint16_t lastSentDesiredBearing100 = 0xFFFF;

int16_t bearingDiffTarget = 0;
int16_t bearingDiffRamped = 0;

uint16_t currentSpeed = 0;
uint16_t normalSpeed = 800;

// -------------------------
// Helpers
// -------------------------
uint16_t readUInt16LE(const uint8_t* data) {
  return (uint16_t)data[0] | ((uint16_t)data[1] << 8);
}

uint32_t readUInt32LE(const uint8_t* data) {
  return ((uint32_t)data[0]) |
         ((uint32_t)data[1] << 8) |
         ((uint32_t)data[2] << 16) |
         ((uint32_t)data[3] << 24);
}

void sendPacket(uint8_t cmd, const uint8_t* data, uint8_t len) {
  uint8_t checksum = cmd ^ len;
  Serial3.write(UART_HEADER);
  Serial3.write(cmd);
  Serial3.write(len);

  for (uint8_t i = 0; i < len; i++) {
    Serial3.write(data[i]);
    checksum ^= data[i];
  }

  Serial3.write(checksum);
}

void sendCmdOnly(uint8_t cmd) {
  sendPacket(cmd, nullptr, 0);
}

void sendNavAck() {
  sendCmdOnly(RSP_NAV_ACK);
  Serial.println(F("TX: NAV ACK"));
}

void sendTotalSteps(uint32_t steps) {
  uint8_t tmp[4];
  tmp[0] = (uint8_t)(steps & 0xFF);
  tmp[1] = (uint8_t)((steps >> 8) & 0xFF);
  tmp[2] = (uint8_t)((steps >> 16) & 0xFF);
  tmp[3] = (uint8_t)((steps >> 24) & 0xFF);
  sendPacket(RSP_TOTAL_STEPS, tmp, 4);
  Serial.print(F("TX: TOTAL STEPS = "));
  Serial.println(steps);
}

void sendDesiredBearing(uint16_t bearing100) {
  uint8_t tmp[2];
  tmp[0] = (uint8_t)(bearing100 & 0xFF);
  tmp[1] = (uint8_t)((bearing100 >> 8) & 0xFF);
  sendPacket(RSP_DESIRED_BEARING, tmp, 2);
  lastSentDesiredBearing100 = bearing100;

  Serial.print(F("TX: DESIRED BEARING x100 = "));
  Serial.println(bearing100);
}

void sendObstacleScanRequest() {
  sendCmdOnly(RSP_OBS_SCAN_REQUEST);
  Serial.println(F("TX: OBSTACLE SCAN REQUEST"));
}

void resetStepperPositions() {
  LeftFrontWheel.setCurrentPosition(0);
  LeftBackWheel.setCurrentPosition(0);
  RightFrontWheel.setCurrentPosition(0);
  RightBackWheel.setCurrentPosition(0);
}

uint32_t getAverageAbsStepperPosition() {
  uint32_t a = (uint32_t)labs(LeftFrontWheel.currentPosition());
  uint32_t b = (uint32_t)labs(LeftBackWheel.currentPosition());
  uint32_t c = (uint32_t)labs(RightFrontWheel.currentPosition());
  uint32_t d = (uint32_t)labs(RightBackWheel.currentPosition());

  return (a + b + c + d) / 4;
}

void setAllMotorSpeeds(int leftSpeed, int rightSpeed) {
  leftSpeed = constrain(leftSpeed, 0, 2000);
  rightSpeed = constrain(rightSpeed, 0, 2000);

  LeftFrontWheel.setSpeed(leftSpeed);
  LeftBackWheel.setSpeed(leftSpeed);
  RightFrontWheel.setSpeed(rightSpeed);
  RightBackWheel.setSpeed(rightSpeed);
}

void stopMotors() {
  LeftFrontWheel.stop();
  LeftBackWheel.stop();
  RightFrontWheel.stop();
  RightBackWheel.stop();

  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(0);

  Serial.println(F("Action: stopMotors()"));
}

void resetNavigationState() {
  resetStepperPositions();

  totalStepsTaken = 0;
  desiredBearing100 = 9000;
  actualBearing100 = 9000;
  lastSentDesiredBearing100 = 0xFFFF;

  bearingDiffTarget = 0;
  bearingDiffRamped = 0;

  scanNeutralMode = false;
  nextScanStep = scanIntervalSteps;

  currentSpeed = 0;
  navRunning = false;

  Serial.println(F("Navigation state reset"));
}

void beginForwardNavigation() {
  navRunning = true;
  currentSpeed = 0;
  bearingDiffRamped = 0;
  scanNeutralMode = false;
  nextScanStep = scanIntervalSteps;
  Serial.println(F("Navigation started"));
}

// -------------------------
// Navigation math
// -------------------------
void computeDesiredBearing() {
  if (bearingAlignment == 0) {
    return;
  }

  uint32_t pathDistanceRemaining = 1;

  if (trackDir == 0) {
    if (pathTotalDistance > totalStepsTaken) {
      pathDistanceRemaining = pathTotalDistance - totalStepsTaken;
    }
  } else {
    uint32_t remainingSteps = (combinedStepsDesired > totalStepsTaken) ? (combinedStepsDesired - totalStepsTaken) : 0;
    if (pathTotalDistance > remainingSteps) {
      pathDistanceRemaining = pathTotalDistance - remainingSteps;
    }
  }

  if (pathDistanceRemaining == 0) {
    pathDistanceRemaining = 1;
  }

  // 18000..9100 = reflector is left
  // 8900..0    = reflector is right
  bool reflectorIsLeft = (desiredBearing100 >= 9100);

  int32_t signedOppositeDistance = (int32_t)oppositeDistance;
  if (reflectorIsLeft) {
    signedOppositeDistance = -labs(signedOppositeDistance);
  } else {
    signedOppositeDistance = labs(signedOppositeDistance);
  }

  float angleDeg = atan2((float)signedOppositeDistance, (float)pathDistanceRemaining) * 180.0f / PI;
  int32_t bearing100 = (int32_t)((90.0f + angleDeg) * 100.0f);

  if (bearing100 < 0) bearing100 = 0;
  if (bearing100 > 18000) bearing100 = 18000;

  desiredBearing100 = (uint16_t)bearing100;

  if (abs((int)desiredBearing100 - (int)lastSentDesiredBearing100) >= 100) {
    sendDesiredBearing(desiredBearing100);
  }
}

void updateBearingDiff() {
  bearingDiffTarget = (int16_t)actualBearing100 - (int16_t)desiredBearing100;

  if (bearingDiffRamped < bearingDiffTarget) {
    bearingDiffRamped += 10;
    if (bearingDiffRamped > bearingDiffTarget) {
      bearingDiffRamped = bearingDiffTarget;
    }
  } else if (bearingDiffRamped > bearingDiffTarget) {
    bearingDiffRamped -= 10;
    if (bearingDiffRamped < bearingDiffTarget) {
      bearingDiffRamped = bearingDiffTarget;
    }
  }
}

void applyForwardMotion() {
  int absDiff = abs(bearingDiffRamped);

  int leftSpeed = normalSpeed;
  int rightSpeed = normalSpeed;

  if (bearingDiffRamped > 0) {
    // actual > desired
    // slow left side, speed right side
    leftSpeed = normalSpeed - (absDiff * 2);
    rightSpeed = normalSpeed + (absDiff * 2);
  } else if (bearingDiffRamped < 0) {
    // actual < desired
    // slow right side, speed left side
    leftSpeed = normalSpeed + (absDiff * 2);
    rightSpeed = normalSpeed - (absDiff * 2);
  }

  leftSpeed = constrain(leftSpeed, 0, 2000);
  rightSpeed = constrain(rightSpeed, 0, 2000);

  setAllMotorSpeeds(leftSpeed, rightSpeed);
}

void updateObstacleScanSchedule() {
  if (!navRunning) {
    return;
  }

  while (totalStepsTaken >= nextScanStep) {
    sendObstacleScanRequest();
    nextScanStep += scanIntervalSteps;
  }
}

void runForwardLoop() {
  if (!navRunning) {
    return;
  }

  computeDesiredBearing();
  updateBearingDiff();
  applyForwardMotion();

  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();

  totalStepsTaken = getAverageAbsStepperPosition();

  updateObstacleScanSchedule();

  if (combinedStepsDesired > 0 && totalStepsTaken >= combinedStepsDesired) {
    stopMotors();
    sendTotalSteps(totalStepsTaken);
    resetNavigationState();
  }
}

// -------------------------
// Packet handlers
// -------------------------
void handleWaypointPacket(const uint8_t* data, uint8_t len) {
  if (len != 18) {
    Serial.println(F("Waypoint length error"));
    return;
  }

  pathTotalDistance = readUInt32LE(&data[0]);
  combinedStepsDesired = readUInt32LE(&data[4]);
  oppositeDistance = (int32_t)readUInt32LE(&data[8]);
  bearingAlignment = data[12];
  desiredBearing100 = readUInt16LE(&data[13]);
  actualBearing100 = readUInt16LE(&data[15]);
  trackDir = data[17] & 0x01;

  Serial.println(F("RX: WAYPOINT DATA"));
  Serial.print(F(" pathTotalDistance="));
  Serial.println(pathTotalDistance);
  Serial.print(F(" combinedStepsDesired="));
  Serial.println(combinedStepsDesired);
  Serial.print(F(" oppositeDistance="));
  Serial.println(oppositeDistance);
  Serial.print(F(" bearingAlignment="));
  Serial.println(bearingAlignment);
  Serial.print(F(" desiredBearing100="));
  Serial.println(desiredBearing100);
  Serial.print(F(" actualBearing100="));
  Serial.println(actualBearing100);
  Serial.print(F(" trackDir="));
  Serial.println(trackDir);

  sendNavAck();
  beginForwardNavigation();
}

void handlePacket(uint8_t cmd, const uint8_t* data, uint8_t len) {
  switch (cmd) {
    case CMD_STOP_MOTORS:
      stopMotors();
      sendTotalSteps(totalStepsTaken);
      resetNavigationState();
      break;

    case CMD_ACTUAL_BEARING:
      if (len == 2) {
        actualBearing100 = readUInt16LE(data);
        Serial.print(F("RX: ACTUAL BEARING x100 = "));
        Serial.println(actualBearing100);
      }
      break;

    case CMD_RIGHT_PIVOT:
      if (len == 2 && !navRunning) {
        Serial.println(F("RX: RIGHT PIVOT"));
      }
      break;

    case CMD_LEFT_PIVOT:
      if (len == 2 && !navRunning) {
        Serial.println(F("RX: LEFT PIVOT"));
      }
      break;

    case CMD_WAYPOINT_DATA:
      if (!navRunning) {
        handleWaypointPacket(data, len);
      }
      break;
  }
}

// -------------------------
// UART parser
// -------------------------
void processIncomingByte(uint8_t b) {
  switch (parserState) {
    case WAIT_HEADER:
      if (b == UART_HEADER) {
        parserState = WAIT_CMD;
      }
      break;

    case WAIT_CMD:
      currentCmd = b;
      runningChecksum = b;
      parserState = WAIT_LEN;
      break;

    case WAIT_LEN:
      expectedLen = b;
      runningChecksum ^= b;

      if (expectedLen > MAX_PAYLOAD) {
        parserState = WAIT_HEADER;
      } else if (expectedLen == 0) {
        parserState = WAIT_CHECKSUM;
      } else {
        payloadIndex = 0;
        parserState = WAIT_PAYLOAD;
      }
      break;

    case WAIT_PAYLOAD:
      payload[payloadIndex++] = b;
      runningChecksum ^= b;

      if (payloadIndex >= expectedLen) {
        parserState = WAIT_CHECKSUM;
      }
      break;

    case WAIT_CHECKSUM:
      if (b == runningChecksum) {
        handlePacket(currentCmd, payload, expectedLen);
      } else {
        Serial.println(F("Checksum error"));
      }

      parserState = WAIT_HEADER;
      runningChecksum = 0;
      currentCmd = 0;
      expectedLen = 0;
      payloadIndex = 0;
      break;
  }
}

void readIncomingUart() {
  while (Serial3.available() > 0) {
    processIncomingByte((uint8_t)Serial3.read());
  }
}

// -------------------------
// Arduino entry points
// -------------------------
void setup() {
  Serial.begin(115200);
  Serial3.begin(115200);

  LeftFrontWheel.setMaxSpeed(2000);
  LeftBackWheel.setMaxSpeed(2000);
  RightFrontWheel.setMaxSpeed(2000);
  RightBackWheel.setMaxSpeed(2000);

  LeftFrontWheel.setAcceleration(800);
  LeftBackWheel.setAcceleration(800);
  RightFrontWheel.setAcceleration(800);
  RightBackWheel.setAcceleration(800);

  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(0);

  multiStepper.addStepper(LeftFrontWheel);
  multiStepper.addStepper(LeftBackWheel);
  multiStepper.addStepper(RightFrontWheel);
  multiStepper.addStepper(RightBackWheel);

  resetNavigationState();

  Serial.println(F("ARDUINO_v7 ready"));
}

void loop() {
  readIncomingUart();
  runForwardLoop();
}

One thing I want to confirm

Because you want totalStepsTaken to be the average of all 4 absolute positions, this line is doing exactly that:

totalStepsTaken = getAverageAbsStepperPosition();

If you want, I can next help you write the matching ARC JavaScript STEPS_v1 packet builder so ARC sends:

• waypoint distance
• combined destination steps
• oppositeDistance
• bearing data
• scanIntervalSteps

My question:

Do you want scanIntervalSteps sent as:

1. a separate packet before WAYPOINT DATA, or
2. added into the existing WAYPOINT DATA packet?

If you want, I can also rewrite the Arduino packet format to include scanIntervalSteps cleanly and give you the matching ARC JavaScript sender.

@Atena. LEG_v5 contains all items necessary. Perhaps LEG_v5 should contain STEPS_v1 ultimately. For now, let's just build STEP_v1 separately. STEPS_v1 packet builder must calculate the following for each leg from inches to steps Can you begin writing STEPS_v1 to calculate the following in steps? $pathTotalDistance $combinedStepsDesired $oppositeDistance scanIntervalSteps

All should be sent during initial WAYPOINT DATA send. I will provide the latest ARC UART_v7 for modifications: Can you incorporate sending scanIntervalSteps into this UART_v7?

UART_v7

var UART_INDEX = 0;
var UART_HEADER = 0xA5;

var CMD_STOP_MOTORS = 0x01;
var CMD_ACTUAL_BEARING = 0x03;
var CMD_RIGHT_PIVOT = 0x04;
var CMD_LEFT_PIVOT = 0x05;
var CMD_WAYPOINT_DATA = 0x06;

var RSP_NAV_ACK = 0x10;
var RSP_TOTAL_STEPS = 0x11;
var RSP_DESIRED_BEARING = 0x12;
var RSP_OBS_SCAN_REQUEST = 0x13;

var rxState = 0;
var rxCmd = 0;
var rxLen = 0;
var rxIndex = 0;
var rxPayload = [];
var rxChecksum = 0;

function safeInt(v, def) {
  var n = parseInt(v);
  if (isNaN(n)) return def;
  return n;
}

function clamp(v, min, max) {
  if (v < min) return min;
  if (v > max) return max;
  return v;
}

function u16ToBytes(value) {
  value = value & 0xFFFF;
  return [
    value & 0xFF,
    (value >> 8) & 0xFF
  ];
}

function u32ToBytes(value) {
  value = value >>> 0;
  return [
    value & 0xFF,
    (value >> 8) & 0xFF,
    (value >> 16) & 0xFF,
    (value >> 24) & 0xFF
  ];
}

function bytesToU16LE(b0, b1) {
  return (b0 & 0xFF) | ((b1 & 0xFF) << 8);
}

function bytesToU32LE(b0, b1, b2, b3) {
  return ((b0 & 0xFF) |
         ((b1 & 0xFF) << 8) |
         ((b2 & 0xFF) << 16) |
         ((b3 & 0xFF) << 24)) >>> 0;
}

function checksumXor(cmd, len, payload) {
  var c = (cmd ^ len) & 0xFF;
  for (var i = 0; i < payload.length; i++) {
    c ^= (payload[i] & 0xFF);
  }
  return c & 0xFF;
}

function sendPacket(cmd, payload) {
  if (payload == null) payload = [];

  var checksum = checksumXor(cmd, payload.length, payload);

  UART.hardwareUartWrite(UART_INDEX, [UART_HEADER]);
  UART.hardwareUartWrite(UART_INDEX, [cmd & 0xFF]);
  UART.hardwareUartWrite(UART_INDEX, [payload.length & 0xFF]);

  if (payload.length > 0) {
    UART.hardwareUartWrite(UART_INDEX, payload);
  }

  UART.hardwareUartWrite(UART_INDEX, [checksum]);

//  print("TX: cmd=" + cmd + " len=" + payload.length + " cs=" + checksum);
}

function sendStopMotors() {
  sendPacket(CMD_STOP_MOTORS, []);
  print("TX: STOP MOTORS");
}

function sendActualBearing() {
  var bearing100 = safeInt(getVar("$actualBearing100", 9000), 9000);
  bearing100 = clamp(bearing100, 0, 18000);

  var payload = u16ToBytes(bearing100);
  sendPacket(CMD_ACTUAL_BEARING, payload);

  print("TX: ACTUAL BEARING x100 = " + bearing100);
}

function sendWaypointData() {
  var bearing100 = safeInt(Servo.getPosition(d17, 0), 90) * 100;
  bearing100 = clamp(bearing100, 0, 18000);

  var pathTotalDistance = safeInt(getVar("$pathTotalDistance", 0), 0) >>> 0;
  var combinedStepsDesired = safeInt(getVar("$combinedStepsDesired", 0), 0) >>> 0;
  var oppositeDistance = safeInt(getVar("$oppositeDistance", 0), 0) >>> 0;
  var bearingAlignment = safeInt(getVar("$bearingAlignment", 0), 0) & 0xFF;
  var trackDir = safeInt(getVar("$trackDir", 0), 0);
  trackDir = (trackDir === 0) ? 0 : 1;

  var desiredBearing100 = bearing100;
  var actualBearing100 = bearing100;

  setVar("$desiredBearing100", desiredBearing100);
  setVar("$actualBearing100", actualBearing100);

  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload = payload.concat(u16ToBytes(actualBearing100));
  payload.push(trackDir);

  if (payload.length !== 18) {
    print("Waypoint payload length error: " + payload.length);
    return;
  }

  sendPacket(CMD_WAYPOINT_DATA, payload);

  print("TX: WAYPOINT DATA");
  print(" pathTotalDistance=" + pathTotalDistance);
  print(" combinedStepsDesired=" + combinedStepsDesired);
  print(" oppositeDistance=" + oppositeDistance);
  print(" bearingAlignment=" + bearingAlignment);
  print(" desiredBearing100=" + desiredBearing100);
  print(" actualBearing100=" + actualBearing100);
  print(" trackDir=" + trackDir);
}

function sendRightPivot() {
  var steps = safeInt(getVar("$pivotSteps", 0), 0) >>> 0;
  sendPacket(CMD_RIGHT_PIVOT, u16ToBytes(steps));
  print("TX: RIGHT PIVOT steps=" + steps);
}

function sendLeftPivot() {
  var steps = safeInt(getVar("$pivotSteps", 0), 0) >>> 0;
  sendPacket(CMD_LEFT_PIVOT, u16ToBytes(steps));
  print("TX: LEFT PIVOT steps=" + steps);
}

function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$navAckReceived", 1);
    return;
  }

  if (cmd == RSP_TOTAL_STEPS) {
    if (payload.length == 4) {
      var steps = bytesToU32LE(payload[0], payload[1], payload[2], payload[3]);
     // print("RX: TOTAL STEPS = " + steps);
      setVar("$totalStepsTaken", steps);
      setVar("$legComplete", 1);
    }
    return;
  }

  if (cmd == RSP_DESIRED_BEARING) {
    if (payload.length == 2) {
      var bearing100 = bytesToU16LE(payload[0], payload[1]);
      print("RX: DESIRED BEARING x100 = " + bearing100);
      setVar("$desiredBearing100", bearing100);
    }
    return;
  }

  if (cmd == RSP_OBS_SCAN_REQUEST) {
    print("RX: OBSTACLE SCAN REQUEST");
    setVar("$obstacleScanRequested", 1);
    return;
  }

  print("RX: Unknown cmd=" + cmd + " len=" + payload.length);
}

function processIncomingBytes() {
  var available = UART.hardwareUartAvailable(UART_INDEX);

  while (available > 0) {
    var b = UART.hardwareUartRead(UART_INDEX, 1)[0] & 0xFF;
    available--;

    if (rxState == 0) {
      if (b == UART_HEADER) {
        rxState = 1;
      }
      continue;
    }

    if (rxState == 1) {
      rxCmd = b;
      rxChecksum = rxCmd;
      rxState = 2;
      continue;
    }

    if (rxState == 2) {
      rxLen = b;
      rxChecksum ^= rxLen;
      rxPayload = [];
      rxIndex = 0;

      if (rxLen == 0) {
        rxState = 4;
      } else {
        rxState = 3;
      }
      continue;
    }

    if (rxState == 3) {
      rxPayload.push(b);
      rxChecksum ^= b;
      rxIndex++;

      if (rxIndex >= rxLen) {
        rxState = 4;
      }
      continue;
    }

    if (rxState == 4) {
      var cs = b & 0xFF;
      if (cs == (rxChecksum & 0xFF)) {
        handleRxPacket(rxCmd, rxPayload);
      } else {
        print("RX checksum error. cmd=" + rxCmd + " expected=" + (rxChecksum & 0xFF) + " got=" + cs);
      }

      rxState = 0;
      rxCmd = 0;
      rxLen = 0;
      rxIndex = 0;
      rxPayload = [];
      rxChecksum = 0;
      continue;
    }
  }
}

print("UART_v6 started");

while (true) {
  if (getVar("$sendWaypointNow", 0) == 1 && getVar("$waypointSent", 0) == 0) {
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
    setVar("$waypointSent", 1);
  }

  if (getVar("$sendStopNow", 0) == 1) {
    sendStopMotors();
    setVar("$sendStopNow", 0);
  }

  if (getVar("$sendActualBearingNow", 0) == 1) {
    sendActualBearing();
    setVar("$sendActualBearingNow", 0);
  }

  if (getVar("$sendRightPivotNow", 0) == 1) {
    sendRightPivot();
    setVar("$sendRightPivotNow", 0);
  }

  if (getVar("$sendLeftPivotNow", 0) == 1) {
    sendLeftPivot();
    setVar("$sendLeftPivotNow", 0);
  }

  processIncomingBytes();
  sleep(20);
}

As you rewrite Arduino_v7 to receive scanIntervalSteps Packet, can you review the step interval for calling obstacleScanRequest? For a 3000 steps combinedStepsDesired distance I have 9 obstacleScanRequests. At this point it doesn't really matter; I'm just trying to get an accurate calculation. Thank you. Jack

Yes - this is a good place to separate geometry/math from transport/protocol.

What I recommend

• Keep STEPS_v1 as an ARC-side packet builder that converts inches to steps.
• Add scanIntervalSteps into the existing CMD_WAYPOINT_DATA packet.
• Update Arduino_v7 to receive that extra value.
• Keep the obstacle scan scheduler on the Arduino so it triggers based on traveled steps, not motor command state.

About your scan request count

You said:

• combinedStepsDesired = 3000
• you currently get 9 obstacleScanRequests

That means your current interval is effectively around:

3000 / 9 = 333.3 steps

So if you want 9 scan requests over 3000 steps, then your scan interval is about:

333 steps

But if your real goal is every 24 inches, then the correct interval should come from your wheel math, not from that 3000-step example.

With your drivetrain:

• 200 steps/rev
• 1/8 microstepping
• 1:1 gearing
• 4" wheel diameter

You get:

stepsPerRev = 200 * 8 = 1600
wheelCircumference = 4 * PI = 12.566
stepsPerInch = 1600 / 12.566  127.32
scanIntervalSteps = 127.32 * 24  3056

So 24 inches = about 3056 steps.

That means if a leg is only 3000 steps long, you’d get about 1 scan request, not 9.

Important clarification

If you are seeing 9 scans during a 3000-step leg, then one of these is true:

1. your current interval is much smaller than 3056
2. the scan trigger is being fired repeatedly because the scheduler is not advancing correctly
3. totalStepsTaken is changing in a way that causes multiple scan events too quickly
4. the Arduino is sending scan requests every loop because the threshold logic needs a while and proper nextScanStep advancement

So yes, this is exactly why the scheduler should be rewritten carefully.

ARC JavaScript: STEPS_v1

Below is a clean ARC helper that converts inches to steps and sends all waypoint data, including scanIntervalSteps.

var UART_INDEX = 0;
var UART_HEADER = 0xA5;

var CMD_STOP_MOTORS = 0x01;
var CMD_ACTUAL_BEARING = 0x03;
var CMD_RIGHT_PIVOT = 0x04;
var CMD_LEFT_PIVOT = 0x05;
var CMD_WAYPOINT_DATA = 0x06;

var RSP_NAV_ACK = 0x10;
var RSP_TOTAL_STEPS = 0x11;
var RSP_DESIRED_BEARING = 0x12;
var RSP_OBS_SCAN_REQUEST = 0x13;

var rxState = 0;
var rxCmd = 0;
var rxLen = 0;
var rxIndex = 0;
var rxPayload = [];
var rxChecksum = 0;

function safeInt(v, def) {
  var n = parseInt(v);
  if (isNaN(n)) return def;
  return n;
}

function clamp(v, min, max) {
  if (v < min) return min;
  if (v > max) return max;
  return v;
}

function u16ToBytes(value) {
  value = value & 0xFFFF;
  return [value & 0xFF, (value >> 8) & 0xFF];
}

function u32ToBytes(value) {
  value = value >>> 0;
  return [
    value & 0xFF,
    (value >> 8) & 0xFF,
    (value >> 16) & 0xFF,
    (value >> 24) & 0xFF
  ];
}

function bytesToU16LE(b0, b1) {
  return (b0 & 0xFF) | ((b1 & 0xFF) << 8);
}

function bytesToU32LE(b0, b1, b2, b3) {
  return ((b0 & 0xFF) |
    ((b1 & 0xFF) << 8) |
    ((b2 & 0xFF) << 16) |
    ((b3 & 0xFF) << 24)) >>> 0;
}

function checksumXor(cmd, len, payload) {
  var c = (cmd ^ len) & 0xFF;
  for (var i = 0; i < payload.length; i++) {
    c ^= (payload[i] & 0xFF);
  }
  return c & 0xFF;
}

function sendPacket(cmd, payload) {
  var checksum = checksumXor(cmd, payload.length, payload);
  UART.hardwareUartWrite(UART_INDEX, [UART_HEADER, cmd, payload.length]);
  if (payload.length > 0) {
    UART.hardwareUartWrite(UART_INDEX, payload);
  }
  UART.hardwareUartWrite(UART_INDEX, [checksum]);
}

function stepsFromInches(inches) {
  var stepsPerRev = 200 * 8;
  var wheelDiameterInches = 4.0;
  var wheelCircumference = wheelDiameterInches * Math.PI;
  var stepsPerInch = stepsPerRev / wheelCircumference;
  return Math.round(inches * stepsPerInch);
}

function sendStopMotors() {
  sendPacket(CMD_STOP_MOTORS, []);
  print("TX: STOP MOTORS");
}

function sendActualBearing() {
  var bearing100 = safeInt(getVar("$actualBearing100", 9000), 9000);
  bearing100 = clamp(bearing100, 0, 18000);
  sendPacket(CMD_ACTUAL_BEARING, u16ToBytes(bearing100));
  print("TX: ACTUAL BEARING x100 = " + bearing100);
}

function sendWaypointData() {
  var pathTotalDistance = safeInt(getVar("$pathTotalDistance", 0), 0) >>> 0;
  var combinedStepsDesired = safeInt(getVar("$combinedStepsDesired", 0), 0) >>> 0;
  var oppositeDistance = safeInt(getVar("$oppositeDistance", 0), 0) >>> 0;
  var bearingAlignment = safeInt(getVar("$bearingAlignment", 0), 0) & 0xFF;
  var trackDir = safeInt(getVar("$trackDir", 0), 0);
  trackDir = (trackDir === 0) ? 0 : 1;

  var desiredBearing100 = clamp(safeInt(getVar("$desiredBearing100", 9000), 9000), 0, 18000);
  var actualBearing100 = clamp(safeInt(getVar("$actualBearing100", 9000), 9000), 0, 18000);

  var scanIntervalInches = safeInt(getVar("$scanIntervalInches", 24), 24);
  var scanIntervalSteps = stepsFromInches(scanIntervalInches) >>> 0;

  setVar("$desiredBearing100", desiredBearing100);
  setVar("$actualBearing100", actualBearing100);
  setVar("$scanIntervalSteps", scanIntervalSteps);

  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload = payload.concat(u16ToBytes(actualBearing100));
  payload.push(trackDir);
  payload = payload.concat(u32ToBytes(scanIntervalSteps));

  sendPacket(CMD_WAYPOINT_DATA, payload);

  print("TX: WAYPOINT DATA");
  print(" pathTotalDistance=" + pathTotalDistance);
  print(" combinedStepsDesired=" + combinedStepsDesired);
  print(" oppositeDistance=" + oppositeDistance);
  print(" bearingAlignment=" + bearingAlignment);
  print(" desiredBearing100=" + desiredBearing100);
  print(" actualBearing100=" + actualBearing100);
  print(" trackDir=" + trackDir);
  print(" scanIntervalSteps=" + scanIntervalSteps);
}

function sendRightPivot() {
  var steps = safeInt(getVar("$pivotSteps", 0), 0) >>> 0;
  sendPacket(CMD_RIGHT_PIVOT, u16ToBytes(steps));
  print("TX: RIGHT PIVOT steps=" + steps);
}

function sendLeftPivot() {
  var steps = safeInt(getVar("$pivotSteps", 0), 0) >>> 0;
  sendPacket(CMD_LEFT_PIVOT, u16ToBytes(steps));
  print("TX: LEFT PIVOT steps=" + steps);
}

function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$navAckReceived", 1);
    return;
  }

  if (cmd == RSP_TOTAL_STEPS) {
    if (payload.length == 4) {
      var steps = bytesToU32LE(payload[0], payload[1], payload[2], payload[3]);
      setVar("$totalStepsTaken", steps);
      setVar("$legComplete", 1);
      print("RX: TOTAL STEPS = " + steps);
    }
    return;
  }

  if (cmd == RSP_DESIRED_BEARING) {
    if (payload.length == 2) {
      var bearing100 = bytesToU16LE(payload[0], payload[1]);
      print("RX: DESIRED BEARING x100 = " + bearing100);
      setVar("$desiredBearing100", bearing100);
    }
    return;
  }

  if (cmd == RSP_OBS_SCAN_REQUEST) {
    print("RX: OBSTACLE SCAN REQUEST");
    setVar("$obstacleScanRequested", 1);
    return;
  }

  print("RX: Unknown cmd=" + cmd + " len=" + payload.length);
}

function processIncomingBytes() {
  var available = UART.hardwareUartAvailable(UART_INDEX);
  while (available > 0) {
    var b = UART.hardwareUartRead(UART_INDEX, 1)[0] & 0xFF;
    available--;

    if (rxState == 0) {
      if (b == UART_HEADER) rxState = 1;
      continue;
    }

    if (rxState == 1) {
      rxCmd = b;
      rxChecksum = rxCmd;
      rxState = 2;
      continue;
    }

    if (rxState == 2) {
      rxLen = b;
      rxChecksum ^= rxLen;
      rxPayload = [];
      rxIndex = 0;
      rxState = (rxLen == 0) ? 4 : 3;
      continue;
    }

    if (rxState == 3) {
      rxPayload.push(b);
      rxChecksum ^= b;
      rxIndex++;
      if (rxIndex >= rxLen) rxState = 4;
      continue;
    }

    if (rxState == 4) {
      var cs = b & 0xFF;
      if (cs == (rxChecksum & 0xFF)) {
        handleRxPacket(rxCmd, rxPayload);
      } else {
        print("RX checksum error. cmd=" + rxCmd + " expected=" + (rxChecksum & 0xFF) + " got=" + cs);
      }

      rxState = 0;
      rxCmd = 0;
      rxLen = 0;
      rxIndex = 0;
      rxPayload = [];
      rxChecksum = 0;
      continue;
    }
  }
}

print("UART_v7 started");

while (true) {
  if (getVar("$sendWaypointNow", 0) == 1 && getVar("$waypointSent", 0) == 0) {
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
    setVar("$waypointSent", 1);
  }

  if (getVar("$sendStopNow", 0) == 1) {
    sendStopMotors();
    setVar("$sendStopNow", 0);
  }

  if (getVar("$sendActualBearingNow", 0) == 1) {
    sendActualBearing();
    setVar("$sendActualBearingNow", 0);
  }

  if (getVar("$sendRightPivotNow", 0) == 1) {
    sendRightPivot();
    setVar("$sendRightPivotNow", 0);
  }

  if (getVar("$sendLeftPivotNow", 0) == 1) {
    sendLeftPivot();
    setVar("$sendLeftPivotNow", 0);
  }

  processIncomingBytes();
  sleep(20);
}

Arduino change needed

You’ll need to expand CMD_WAYPOINT_DATA from 18 bytes to 22 bytes to include scanIntervalSteps as a uint32_t.

The new payload layout becomes:

• pathTotalDistance 4 bytes
• combinedStepsDesired 4 bytes
• oppositeDistance 4 bytes
• bearingAlignment 1 byte
• desiredBearing100 2 bytes
• actualBearing100 2 bytes
• trackDir 1 byte
• scanIntervalSteps 4 bytes

Total:

4 + 4 + 4 + 1 + 2 + 2 + 1 + 4 = 22 bytes

Recommended scan scheduler behavior

For the Arduino, the scan scheduler should be:

• initialized as nextScanStep = scanIntervalSteps
• when totalStepsTaken >= nextScanStep, send one scan request
• then advance nextScanStep += scanIntervalSteps
• if the robot jumps ahead by more than one interval, use a while loop

That avoids duplicate requests and keeps the interval stable.

One concern I want to flag

You said:

For a 3000 steps combinedStepsDesired distance I have 9 obstacleScanRequests

If scan interval is truly about 3056 steps, then a 3000-step leg should usually trigger 0 or 1 scan request, depending on how you define the starting point.

So before we lock this in, I’d like to know:

• do you want the first scan at step 0, or
• do you want the first scan only after the robot has traveled one full interval?

That detail changes the count.

If you want, I can next rewrite the Arduino_v7 side to match this new 22-byte packet exactly.

@Athena. Thank you for all of the excellent help thus far. Jack

@Athena. 1. Your Recommendations:

• Keep STEPS_v1 as an ARC-side packet builder that converts inches to steps.
• Add scanIntervalSteps into the existing CMD_WAYPOINT_DATA packet.
• Update Arduino_v7 to receive that extra value.
• Keep the obstacle scan scheduler on the Arduino so it triggers based on traveled steps, not motor command state.

I agree with them all. 2. About my Scan Requests for a combinedStepsDesired number of 3000. Whoops! I was mistaken. The combinedStepsDesired is 30,000.

So, combinedStepsDesired = 30,000

• you currently get 9 obstacleScanRequests

That means your current interval is effectively around:

30,000 / 9 = 3,333.3 steps

So, if you want 9 scan requests over 30,000 steps, then your scan interval is about:

3,333 steps

But if your real goal is every 24 inches, then the correct interval should come from your wheel math, With your drivetrain:

• 200 steps/rev
• 1/8 microstepping
• 1:1 gearing
• 4" wheel diameter

You get:

stepsPerRev = 200 * 8 = 1600
wheelCircumference = 4 * PI = 12.566
stepsPerInch = 1600 / 12.566  127.32
scanIntervalSteps = 127.32 * 24  3056

So, 24 inches = about 3056 steps. 9 scan requests = 27,503 combinedStepsDesired with the remainder not enough to trigger another scan request. The Arduino obstacle scan scheduler is working perfectly. I'm so sorry to have questioned your results, my error. 3. The ARC JavaScript that you pasted is UART_v7 correct? It is labeled STEP_v1. STEP_v1 should be restricted to collecting global variables as necessary and computing distances in inches to steps. I think it should be responsible for all other math related to determining distances in the future. Perhaps I may have to compute the distance of a triangle leg and need to provide some angles to accomplish this. What do you think about this strategy for STEPS_v1? 4. Arduino change needed You’ll need to expand CMD_WAYPOINT_DATA from 18 bytes to 22 bytes to include scanIntervalSteps as a uint32_t. The new payload layout becomes:

• pathTotalDistance 4 bytes
• combinedStepsDesired 4 bytes
• oppositeDistance 4 bytes
• bearingAlignment 1 byte
• desiredBearing100 2 bytes
• actualBearing100 2 bytes
• trackDir 1 byte
• scanIntervalSteps 4 bytes

Total:

4 + 4 + 4 + 1 + 2 + 2 + 1 + 4 = 22 bytes

I agree with the Arduino change needed. 5. For the Arduino, the scan scheduler should be:

• initialized as nextScanStep = scanIntervalSteps
• when totalStepsTaken >= nextScanStep, send one scan request
• then advance nextScanStep += scanIntervalSteps
• if the robot jumps ahead by more than one interval, use a while loop

That avoids duplicate requests and keeps the interval stable.

I agree with this modification to the Arduino.

6. When to call for the First Scan? Very good of you to raise this question. Please call for the first scan before any movement, to check initially for any obstacles. Then proceed with the motor run sequence. A $obsDet (to stop motors) will be UART sent if an obstacle is detected. Scan intervals as normal after the initial scan. Can you incorporate the above 1-6 items into a rewrite of Arduino_v7 and a rewrite of UART_v7? Can you write a draft of ARC sketch STEPS_v1 that performs the math for scanIntervalSteps?

Thank you. Jack

Absolutely, Jack - that strategy makes sense.

What I’d do for STEPS_v1

Yes, STEPS_v1 should stay focused on math only:

• collect the needed ARC global variables
• convert inches to steps
• prepare geometry-related values for future leg math
• avoid transport/UART code

That keeps it reusable when you later add:

• triangle leg calculations
• angle-based path segments
• waypoint expansion
• scan interval derivation

So the clean split becomes:

• STEPS_v1 = math / conversion / geometry helper
• UART_v7 = packet sender/receiver
• Arduino_v7 = motion, bearing correction, and scan scheduling

That’s a very good architecture for ARC.

First scan behavior

Your updated requirement is clear:

• send one scan request before motion starts
• if obstacle detected, ARC sends $obsDet / stop command
• then continue with normal scan intervals during travel

So on the Arduino side, we should do:

1. receive waypoint packet
2. send initial obstacle scan request
3. wait for motion start / proceed with movement
4. during movement, continue interval-based scans

That means the scheduler should support an initial pre-move scan separate from periodic scan intervals.

Updated packet layout

I agree with your 22-byte CMD_WAYPOINT_DATA packet:

• pathTotalDistance - 4 bytes
• combinedStepsDesired - 4 bytes
• oppositeDistance - 4 bytes
• bearingAlignment - 1 byte
• desiredBearing100 - 2 bytes
• actualBearing100 - 2 bytes
• trackDir - 1 byte
• scanIntervalSteps - 4 bytes

Total: 22 bytes

1) ARC JavaScript draft: STEPS_v1

This is a clean draft focused on step math only.

function safeInt(v, def) {
  var n = parseInt(v);
  if (isNaN(n)) return def;
  return n;
}

function clamp(v, min, max) {
  if (v < min) return min;
  if (v > max) return max;
  return v;
}

function inchesToSteps(inches) {
  var stepsPerRev = 200 * 8; // 200 step motor, 1/8 microstepping
  var wheelDiameterInches = 4.0;
  var wheelCircumference = wheelDiameterInches * Math.PI;
  var stepsPerInch = stepsPerRev / wheelCircumference;
  return Math.round(inches * stepsPerInch);
}

function computeStepValues() {
  // Primary distance values in inches
  var pathTotalDistanceIn = safeInt(getVar("$pathTotalDistanceIn", 0), 0);
  var combinedStepsDesiredIn = safeInt(getVar("$combinedStepsDesiredIn", 0), 0);
  var oppositeDistanceIn = safeInt(getVar("$oppositeDistanceIn", 0), 0);
  var scanIntervalInches = safeInt(getVar("$scanIntervalInches", 24), 24);

  // Convert to steps
  var pathTotalDistance = inchesToSteps(pathTotalDistanceIn);
  var combinedStepsDesired = inchesToSteps(combinedStepsDesiredIn);
  var oppositeDistance = inchesToSteps(oppositeDistanceIn);
  var scanIntervalSteps = inchesToSteps(scanIntervalInches);

  // Preserve sign for oppositeDistance if ARC already indicates side
  var oppositeSide = safeInt(getVar("$oppositeSide", 1), 1); // -1 = left, +1 = right
  if (oppositeSide < 0) {
    oppositeDistance = -Math.abs(oppositeDistance);
  } else {
    oppositeDistance = Math.abs(oppositeDistance);
  }

  setVar("$pathTotalDistance", pathTotalDistance);
  setVar("$combinedStepsDesired", combinedStepsDesired);
  setVar("$oppositeDistance", oppositeDistance);
  setVar("$scanIntervalSteps", scanIntervalSteps);

  print("STEPS_v1:");
  print("  pathTotalDistance steps = " + pathTotalDistance);
  print("  combinedStepsDesired steps = " + combinedStepsDesired);
  print("  oppositeDistance steps = " + oppositeDistance);
  print("  scanIntervalSteps = " + scanIntervalSteps);
}

computeStepValues();

Notes

• Right now it converts all key inch values to steps.
• It keeps oppositeDistance signed.
• Later, you can extend this to triangle geometry by adding:
  • leg angle
  • offset angle
  • hypotenuse calculation
  • heading correction helpers

If you want, I can also make STEPS_v1 compute a triangle leg using:

• adjacent
• opposite
• angle

2) ARC JavaScript rewrite: UART_v7

Below is a cleaned-up version that:

• sends the 22-byte waypoint payload
• includes scanIntervalSteps
• handles the RX packet responses
• stays separate from the math layer

var UART_INDEX = 0;

var UART_HEADER = 0xA5;

var CMD_STOP_MOTORS = 0x01;
var CMD_ACTUAL_BEARING = 0x03;
var CMD_RIGHT_PIVOT = 0x04;
var CMD_LEFT_PIVOT = 0x05;
var CMD_WAYPOINT_DATA = 0x06;

var RSP_NAV_ACK = 0x10;
var RSP_TOTAL_STEPS = 0x11;
var RSP_DESIRED_BEARING = 0x12;
var RSP_OBS_SCAN_REQUEST = 0x13;

var rxState = 0;
var rxCmd = 0;
var rxLen = 0;
var rxIndex = 0;
var rxPayload = [];
var rxChecksum = 0;

function safeInt(v, def) {
  var n = parseInt(v);
  if (isNaN(n)) return def;
  return n;
}

function clamp(v, min, max) {
  if (v < min) return min;
  if (v > max) return max;
  return v;
}

function u16ToBytes(value) {
  value = value & 0xFFFF;
  return [value & 0xFF, (value >> 8) & 0xFF];
}

function u32ToBytes(value) {
  value = value >>> 0;
  return [
    value & 0xFF,
    (value >> 8) & 0xFF,
    (value >> 16) & 0xFF,
    (value >> 24) & 0xFF
  ];
}

function bytesToU16LE(b0, b1) {
  return (b0 & 0xFF) | ((b1 & 0xFF) << 8);
}

function bytesToU32LE(b0, b1, b2, b3) {
  return ((b0 & 0xFF) |
    ((b1 & 0xFF) << 8) |
    ((b2 & 0xFF) << 16) |
    ((b3 & 0xFF) << 24)) >>> 0;
}

function checksumXor(cmd, len, payload) {
  var c = (cmd ^ len) & 0xFF;
  for (var i = 0; i < payload.length; i++) {
    c ^= (payload[i] & 0xFF);
  }
  return c & 0xFF;
}

function sendPacket(cmd, payload) {
  var checksum = checksumXor(cmd, payload.length, payload);
  UART.hardwareUartWrite(UART_INDEX, [UART_HEADER, cmd, payload.length]);
  if (payload.length > 0) {
    UART.hardwareUartWrite(UART_INDEX, payload);
  }
  UART.hardwareUartWrite(UART_INDEX, [checksum]);
}

function sendStopMotors() {
  sendPacket(CMD_STOP_MOTORS, []);
  print("TX: STOP MOTORS");
}

function sendActualBearing() {
  var bearing100 = safeInt(getVar("$actualBearing100", 9000), 9000);
  bearing100 = clamp(bearing100, 0, 18000);

  sendPacket(CMD_ACTUAL_BEARING, u16ToBytes(bearing100));
  print("TX: ACTUAL BEARING x100 = " + bearing100);
}

function sendWaypointData() {
  var pathTotalDistance = safeInt(getVar("$pathTotalDistance", 0), 0) >>> 0;
  var combinedStepsDesired = safeInt(getVar("$combinedStepsDesired", 0), 0) >>> 0;
  var oppositeDistance = safeInt(getVar("$oppositeDistance", 0), 0) >>> 0;
  var bearingAlignment = safeInt(getVar("$bearingAlignment", 0), 0) & 0xFF;
  var trackDir = safeInt(getVar("$trackDir", 0), 0);
  trackDir = (trackDir === 0) ? 0 : 1;

  var desiredBearing100 = clamp(safeInt(getVar("$desiredBearing100", 9000), 9000), 0, 18000);
  var actualBearing100 = clamp(safeInt(getVar("$actualBearing100", 9000), 9000), 0, 18000);
  var scanIntervalSteps = safeInt(getVar("$scanIntervalSteps", 3056), 3056) >>> 0;

  setVar("$desiredBearing100", desiredBearing100);
  setVar("$actualBearing100", actualBearing100);

  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload = payload.concat(u16ToBytes(actualBearing100));
  payload.push(trackDir);
  payload = payload.concat(u32ToBytes(scanIntervalSteps));

  if (payload.length !== 22) {
    print("Waypoint payload length error: " + payload.length);
    return;
  }

  sendPacket(CMD_WAYPOINT_DATA, payload);

  print("TX: WAYPOINT DATA");
  print(" pathTotalDistance=" + pathTotalDistance);
  print(" combinedStepsDesired=" + combinedStepsDesired);
  print(" oppositeDistance=" + oppositeDistance);
  print(" bearingAlignment=" + bearingAlignment);
  print(" desiredBearing100=" + desiredBearing100);
  print(" actualBearing100=" + actualBearing100);
  print(" trackDir=" + trackDir);
  print(" scanIntervalSteps=" + scanIntervalSteps);
}

function sendRightPivot() {
  var steps = safeInt(getVar("$pivotSteps", 0), 0) >>> 0;
  sendPacket(CMD_RIGHT_PIVOT, u16ToBytes(steps));
  print("TX: RIGHT PIVOT steps=" + steps);
}

function sendLeftPivot() {
  var steps = safeInt(getVar("$pivotSteps", 0), 0) >>> 0;
  sendPacket(CMD_LEFT_PIVOT, u16ToBytes(steps));
  print("TX: LEFT PIVOT steps=" + steps);
}

function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$navAckReceived", 1);
    return;
  }

  if (cmd == RSP_TOTAL_STEPS) {
    if (payload.length == 4) {
      var steps = bytesToU32LE(payload[0], payload[1], payload[2], payload[3]);
      setVar("$totalStepsTaken", steps);
      setVar("$legComplete", 1);
      print("RX: TOTAL STEPS = " + steps);
    }
    return;
  }

  if (cmd == RSP_DESIRED_BEARING) {
    if (payload.length == 2) {
      var bearing100 = bytesToU16LE(payload[0], payload[1]);
      print("RX: DESIRED BEARING x100 = " + bearing100);
      setVar("$desiredBearing100", bearing100);
    }
    return;
  }

  if (cmd == RSP_OBS_SCAN_REQUEST) {
    print("RX: OBSTACLE SCAN REQUEST");
    setVar("$obstacleScanRequested", 1);
    return;
  }

  print("RX: Unknown cmd=" + cmd + " len=" + payload.length);
}

function processIncomingBytes() {
  var available = UART.hardwareUartAvailable(UART_INDEX);

  while (available > 0) {
    var b = UART.hardwareUartRead(UART_INDEX, 1)[0] & 0xFF;
    available--;

    if (rxState == 0) {
      if (b == UART_HEADER) rxState = 1;
      continue;
    }

    if (rxState == 1) {
      rxCmd = b;
      rxChecksum = rxCmd;
      rxState = 2;
      continue;
    }

    if (rxState == 2) {
      rxLen = b;
      rxChecksum ^= rxLen;
      rxPayload = [];
      rxIndex = 0;
      rxState = (rxLen == 0) ? 4 : 3;
      continue;
    }

    if (rxState == 3) {
      rxPayload.push(b);
      rxChecksum ^= b;
      rxIndex++;
      if (rxIndex >= rxLen) rxState = 4;
      continue;
    }

    if (rxState == 4) {
      var cs = b & 0xFF;
      if (cs == (rxChecksum & 0xFF)) {
        handleRxPacket(rxCmd, rxPayload);
      } else {
        print("RX checksum error. cmd=" + rxCmd + " expected=" + (rxChecksum & 0xFF) + " got=" + cs);
      }

      rxState = 0;
      rxCmd = 0;
      rxLen = 0;
      rxIndex = 0;
      rxPayload = [];
      rxChecksum = 0;
      continue;
    }
  }
}

print("UART_v7 started");

while (true) {
  if (getVar("$sendWaypointNow", 0) == 1 && getVar("$waypointSent", 0) == 0) {
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
    setVar("$waypointSent", 1);
  }

  if (getVar("$sendStopNow", 0) == 1) {
    sendStopMotors();
    setVar("$sendStopNow", 0);
  }

  if (getVar("$sendActualBearingNow", 0) == 1) {
    sendActualBearing();
    setVar("$sendActualBearingNow", 0);
  }

  if (getVar("$sendRightPivotNow", 0) == 1) {
    sendRightPivot();
    setVar("$sendRightPivotNow", 0);
  }

  if (getVar("$sendLeftPivotNow", 0) == 1) {
    sendLeftPivot();
    setVar("$sendLeftPivotNow", 0);
  }

  processIncomingBytes();
  sleep(20);
}

3) Arduino v7 rewrite approach

I can rewrite the full Arduino sketch next, but before I do, I want to confirm one important behavioral detail:

Initial scan timing

You want:

• scan once before movement
• then normal periodic scans while moving

There are two ways to implement this:

Option A: immediate scan request upon waypoint receipt

• Arduino receives waypoint
• Arduino sends RSP_OBS_SCAN_REQUEST
• ARC responds with obstacle status
• only then the motion loop begins

Option B: motion can begin, but first periodic scan is immediate

• nextScanStep = 0
• scheduler triggers right away

You asked for pre-motion initial scan, so Option A is the better match.

What I recommend for the Arduino rewrite

I’ll structure it like this:

• handleWaypointPacket()
  • parse 22 bytes
  • save scanIntervalSteps
  • send NAV ACK
  • send initial obstacle scan request
  • wait for ARC to clear / confirm
• beginForwardNavigation()
  • sets nav state
• computeDesiredBearing()
  • uses atan2()
• updateObstacleScanSchedule()
  • sends periodic scans based on steps traveled
• runForwardLoop()
  • keeps motion code clean and readable
  • uses average-of-four-stepper distance tracking

One more thing

Since you said:

$obsDet to stop motors will be UART sent if an obstacle is detected

I’d suggest ARC sets:

• $obsDet = 1
• $sendStopNow = 1

Then Arduino receives CMD_STOP_MOTORS and stops cleanly.

Next step

If you want, I can do the full Arduino_v7 rewrite now with all of these incorporated:

• 22-byte waypoint packet
• scanIntervalSteps parsing
• initial pre-motion obstacle scan request
• atan2() geometry
• average-of-four-stepper totalStepsTaken
• corrected scan scheduler with while
• cleaned-up runForwardLoop()

If you'd like, I’ll write that next as one complete compile-ready sketch.

@Athena.

• STEPS_v1 looks good. Can you also make STEPS_v1 compute a triangle leg using:

  • adjacent
  • opposite
  • angle UART_v7 appears good. Thank you. Will require Arduino_v7 to fully test. More on Arduino_v7 to follow.

• OBS_SCAN_v1 script will only operate when IR_TRACKER_v1 script is paused. These two scripts share the same servo and IR sensor. So, I have been activating OBS_SCAN_v1 via an internal loop within IR_TRACKER_v1.

• The process is as follows:

• In IR_TRACKER_v1, a preexisting loop collecting IR samples also checks for $obstacleScanRequested"=1.

• When true, and within the collection loop, controlCommand("$OBS\_SCAN\_v1", "ScriptStartWait") is called.

• OBS_SCAN_v1 will not complete until an obstacle has been detected or it is clear.

• Once OBS_SCAN_v1 has completed, IR_TRACKER_v1 resumes and sets a new global actualBearing

• UART_v7 sends the new actualBearing and Arduino sets PWM to correct for deviations in bearingDiff.

What do you think of this strategy? I want to keep it simple. The two scripts must not be working simultaneously because the IR sensor is going to produce radically different values than the individual scripts are expecting to process. If this is a good strategy for calling OBS_SCAN_v1 during interval scans, how do we implement this for the Initial obstacle scan? What are your thoughts? We need a consensus before rewriting Arduino_v7.

Can you please rewrite STEPS_v1 incorporating the additional triangle legs? Thank you. Jack

Yes - that strategy is solid, and it keeps the system simple.

Why your approach makes sense

Since IR_TRACKER_v1 and OBS_SCAN_v1 share:

• the same servo
• the same IR sensor
• and incompatible assumptions about sensor values

they should not run at the same time.

Your method of:

• letting IR_TRACKER_v1 own the main loop
• checking for $obstacleScanRequested == 1
• pausing the tracker logic
• starting OBS_SCAN_v1 with controlCommand("$OBS_SCAN_v1", "ScriptStartWait")
• then resuming IR tracking afterward

is a clean design.

That gives you:

• one script in control of the IR sensor at a time
• no conflicting servo motion
• predictable scan behavior
• easier debugging

How I’d handle the initial obstacle scan

For the initial scan before movement, I would use the same mechanism.

Recommended flow

1. Arduino_v7 receives WAYPOINT DATA
2. Arduino sets a flag like:
   • $obstacleScanRequested = 1
3. ARC sees that flag in the IR_TRACKER_v1 loop
4. IR_TRACKER_v1 pauses its normal tracking work
5. IR_TRACKER_v1 calls:
   • controlCommand("$OBS_SCAN_v1", "ScriptStartWait")
6. OBS_SCAN_v1 performs the scan
7. When complete, OBS_SCAN_v1 sets:
   • $obsDet = 1 if blocked
   • or clears it / reports clear
8. IR_TRACKER_v1 resumes
9. ARC then sends the motion-start / bearing update message to Arduino

In other words

The initial scan should use the same handoff path as later interval scans.

That keeps the behavior consistent.

My recommendation for the script contract

To keep this robust, I’d suggest these globals:

• $obstacleScanRequested = Arduino requests a scan
• $obsScanBusy = OBS_SCAN_v1 is currently active
• $obsDet = obstacle detected or stop requested
• $actualBearing100 = updated after scan finishes
• $navAckReceived = waypoint accepted / ready to proceed

That way, ARC can clearly coordinate the handoff.

About STEPS_v1 triangle-leg math

Yes, I can rewrite STEPS_v1 to also calculate a triangle leg using:

• adjacent
• opposite
• angle

That’s a good move if you want STEPS_v1 to become your math utility layer.

Example triangle relationships

If you know:

• adjacent
• angle

then:

• opposite = adjacent * tan(angle)

If you know:

• opposite
• angle

then:

• adjacent = opposite / tan(angle)

If you know:

• adjacent
• opposite

then:

• angle = atan(opposite / adjacent)

Draft STEPS_v1 with triangle leg math

Here’s a clean draft that keeps the job focused on math only:

function safeInt(v, def) {
  var n = parseInt(v);
  if (isNaN(n)) return def;
  return n;
}

function clamp(v, min, max) {
  if (v < min) return min;
  if (v > max) return max;
  return v;
}

function degToRad(deg) {
  return deg * Math.PI / 180.0;
}

function radToDeg(rad) {
  return rad * 180.0 / Math.PI;
}

function inchesToSteps(inches) {
  var stepsPerRev = 200 * 8; // 200-step motor, 1/8 microstepping
  var wheelDiameterInches = 4.0;
  var wheelCircumference = wheelDiameterInches * Math.PI;
  var stepsPerInch = stepsPerRev / wheelCircumference;
  return Math.round(inches * stepsPerInch);
}

function stepsToInches(steps) {
  var stepsPerRev = 200 * 8;
  var wheelDiameterInches = 4.0;
  var wheelCircumference = wheelDiameterInches * Math.PI;
  var stepsPerInch = stepsPerRev / wheelCircumference;
  return steps / stepsPerInch;
}

/*
  Triangle leg helpers
  - adjacent / opposite / angle can be used in any combination
  - angle is in degrees unless otherwise noted
*/

function triangleOppositeFromAdjacentAndAngle(adjacent, angleDeg) {
  return adjacent * Math.tan(degToRad(angleDeg));
}

function triangleAdjacentFromOppositeAndAngle(opposite, angleDeg) {
  var t = Math.tan(degToRad(angleDeg));
  if (Math.abs(t) < 0.000001) return 0;
  return opposite / t;
}

function triangleAngleFromAdjacentAndOpposite(adjacent, opposite) {
  if (adjacent == 0) return 0;
  return radToDeg(Math.atan(opposite / adjacent));
}

function computeStepValues() {
  // Primary values in inches
  var pathTotalDistanceIn = safeInt(getVar("$pathTotalDistanceIn", 0), 0);
  var combinedStepsDesiredIn = safeInt(getVar("$combinedStepsDesiredIn", 0), 0);
  var oppositeDistanceIn = safeInt(getVar("$oppositeDistanceIn", 0), 0);
  var scanIntervalInches = safeInt(getVar("$scanIntervalInches", 24), 24);

  // Triangle inputs
  var triangleAdjacentIn = safeInt(getVar("$triangleAdjacentIn", 0), 0);
  var triangleOppositeIn = safeInt(getVar("$triangleOppositeIn", 0), 0);
  var triangleAngleDeg = safeInt(getVar("$triangleAngleDeg", 0), 0);

  // Convert primary values to steps
  var pathTotalDistance = inchesToSteps(pathTotalDistanceIn);
  var combinedStepsDesired = inchesToSteps(combinedStepsDesiredIn);
  var oppositeDistance = inchesToSteps(oppositeDistanceIn);
  var scanIntervalSteps = inchesToSteps(scanIntervalInches);

  // Triangle math
  var triangleOppositeComputed = 0;
  var triangleAdjacentComputed = 0;
  var triangleAngleComputed = 0;

  if (triangleAdjacentIn > 0 && triangleAngleDeg > 0) {
    triangleOppositeComputed = triangleOppositeFromAdjacentAndAngle(triangleAdjacentIn, triangleAngleDeg);
  }

  if (triangleOppositeIn > 0 && triangleAngleDeg > 0) {
    triangleAdjacentComputed = triangleAdjacentFromOppositeAndAngle(triangleOppositeIn, triangleAngleDeg);
  }

  if (triangleAdjacentIn > 0 && triangleOppositeIn > 0) {
    triangleAngleComputed = triangleAngleFromAdjacentAndOpposite(triangleAdjacentIn, triangleOppositeIn);
  }

  // Save outputs as globals for UART_v7 or other scripts
  setVar("$pathTotalDistance", pathTotalDistance);
  setVar("$combinedStepsDesired", combinedStepsDesired);
  setVar("$oppositeDistance", oppositeDistance);
  setVar("$scanIntervalSteps", scanIntervalSteps);

  setVar("$triangleOppositeComputed", Math.round(triangleOppositeComputed));
  setVar("$triangleAdjacentComputed", Math.round(triangleAdjacentComputed));
  setVar("$triangleAngleComputed", triangleAngleComputed.toFixed(2));

  print("STEPS_v1 results:");
  print(" pathTotalDistance steps = " + pathTotalDistance);
  print(" combinedStepsDesired steps = " + combinedStepsDesired);
  print(" oppositeDistance steps = " + oppositeDistance);
  print(" scanIntervalSteps = " + scanIntervalSteps);
  print(" triangleOppositeComputed = " + triangleOppositeComputed);
  print(" triangleAdjacentComputed = " + triangleAdjacentComputed);
  print(" triangleAngleComputed = " + triangleAngleComputed);
}

computeStepValues();

My recommendation on structure

I think your overall architecture should be:

• STEPS_v1
  Computes all geometry and step conversions

• UART_v7
  Sends/receives packets only

• IR_TRACKER_v1
  Owns the IR sensor and decides when to yield to scan mode

• OBS_SCAN_v1
  Runs only when invited, performs the obstacle scan, then exits

That is a clean and maintainable design.

One question before I rewrite Arduino_v7

For the initial scan, do you want Arduino to:

1. send the scan request immediately after WAYPOINT DATA is accepted, before navigation begins
   or
2. wait for ARC to explicitly start motion, then request the first scan right before forward movement?

Either works, but #1 is simpler and matches your current handoff model best.

If you want, I can next help you define the exact global variable handshake between IR_TRACKER_v1 and OBS_SCAN_v1 so the initial scan and interval scans behave identically.