Not quite - that section is not correct.

The immediate problem is this line:

if (rxExpected = rxExpected)

That is an assignment, not a comparison, so it will always evaluate truthy and break the parser logic.

What it should be

You need to check whether enough payload bytes have been read before calling handleRxPacket().

Also, your snippet is missing the payload accumulation logic. Right now you read a byte, but you never store it into rxPayload, so even if the parser advanced correctly, the packet data would be empty.

Corrected processIncomingBytes()

Use this pattern instead:

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

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

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

    if (rxState == 1) {
      rxCmd = b;
      rxExpected = expectedLengthForCmd(rxCmd);

      if (rxExpected < 0) {
        rxState = 0;
        rxIndex = 0;
        rxPayload = [];
        continue;
      }

      if (rxExpected == 0) {
        handleRxPacket(rxCmd, []);
        rxState = 0;
        rxIndex = 0;
        rxPayload = [];
      } else {
        rxPayload = [];
        rxIndex = 0;
        rxState = 2;
      }
      continue;
    }

    if (rxState == 2) {
      rxPayload[rxIndex++] = b;

      if (rxIndex >= rxExpected) {
        handleRxPacket(rxCmd, rxPayload);
        rxState = 0;
        rxIndex = 0;
        rxPayload = [];
      }
    }
  }
}

Why your version fails

Your snippet has 3 issues:

1. Wrong operator

   if (rxExpected = rxExpected)
   

   should not exist.

2. No payload state You jump directly from command byte to packet complete, but packets like:

   • CMD_ACTUAL_BEARING
   • CMD_RIGHT_PIVOT
   • CMD_LEFT_PIVOT
   • CMD_WAYPOINT_DATA

   all require payload bytes after the command.

3. No payload storage Even if bytes arrive, they must be saved into rxPayload.

Also make sure these globals exist before the loop

var rxState = 0;   // 0 = waiting header, 1 = waiting command, 2 = waiting payload
var rxCmd = 0;
var rxExpected = 0;
var rxIndex = 0;
var rxPayload = [];

Recommended packet-length function

This should return the payload byte count only:

function expectedLengthForCmd(cmd) {
  if (cmd == CMD_STOP_MOTORS) return 0;
  if (cmd == CMD_ACTUAL_BEARING) return 2;
  if (cmd == CMD_RIGHT_PIVOT) return 2;
  if (cmd == CMD_LEFT_PIVOT) return 2;
  if (cmd == CMD_WAYPOINT_DATA) return 18;
  return -1;
}

One more important ARC note

In ARC JavaScript, make sure you’re using:

UART.hardwareUartAvailable(UART_INDEX)
UART.hardwareUartRead(UART_INDEX, 1)
UART.hardwareUartWrite(UART_INDEX, packet)

and that your UART skill is configured correctly in the kebab menu.

Minimal test version

If you want to isolate the issue, temporarily test with this:

print("UART_v1 started");

while (true) {
  print("loop tick sendWaypointNow=" + getVar("$sendWaypointNow", 0));

  if (getVar("$sendWaypointNow", 0) == 1) {
    print("sending waypoint");
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
  }

  sleep(500);
}

If that works, then the problem is definitely in the parser section.

If you want, I can rewrite your entire UART_v1 script in one clean block so you can paste it directly into ARC.

@Athena. Please rewrite the entire UART_v1 script so that I can paste it into ARC. Thank you. Jack

Absolutely - below is a clean, paste-ready UART_v1 JavaScript for ARC that:

• sends your ARC Arduino packets
• receives Arduino ARC packets
• uses a non-blocking UART parser
• includes the 18-byte waypoint layout
• updates ARC globals exactly as your flow needs
• avoids the parser bugs that were preventing your script from running

Important: make sure the robot skill name is exactly UART_v1, and that the UART skill is configured correctly via the kebab menu in ARC.

UART_v1 - Paste into ARC

var UART_INDEX = 0;
var UART_HEADER = 0xA5;

// ARC -> Arduino
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;

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

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

function safeFloat(v, def) {
  var n = parseFloat(v);
  if (isNaN(n)) return def;
  return n;
}

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);
}

function sendPacket(cmd, payload) {
  var packet = [UART_HEADER, cmd].concat(payload);
  UART.hardwareUartWrite(UART_INDEX, packet);
}

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

function sendActualBearing() {
  var bearing = safeFloat(getVar("$actualBearing", -1), -1);
  if (bearing < 0) {
    print("TX: Actual bearing not set");
    return;
  }

  var bearing100 = Math.round(bearing * 100.0);
  sendPacket(CMD_ACTUAL_BEARING, u16ToBytes(bearing100));
  print("TX: ACTUAL BEARING x100 = " + bearing100);
}

function sendWaypointData() {
  var pathTotalDistance = safeInt(getVar("$pathTotalDistance", 0), 0);
  var combinedStepsDesired = safeInt(getVar("$combinedStepsDesired", 0), 0);
  var oppositeDistance = safeInt(getVar("$oppositeDistance", 0), 0);
  var bearingAlignment = safeInt(getVar("$bearingAlignment", 0), 0);
  var desiredBearing100 = safeInt(getVar("$desiredBearing100", 9000), 9000);
  var trackDir = safeInt(getVar("$trackDir", 0), 0);

  // 18-byte payload:
  // 0-3  pathTotalDistance uint32
  // 4-7  combinedStepsDesired uint32
  // 8-11 oppositeDistance uint32
  // 12   bearingAlignment uint8
  // 13-14 desiredBearing100 uint16
  // 15-17 trackDir + reserved bytes? 
  //
  // Since your Arduino final sketch uses:
  // pathTotalDistance  [0..3]
  // combinedStepsDesired [4..7]
  // oppositeDistance [8..11]
  // bearingAlignment [12]
  // desiredBearing100 [13..14]
  // trackDir [17]
  //
  // We fill bytes 15 and 16 with 0 padding so the payload is 18 bytes total.
  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment & 0xFF);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload.push(0x00); // reserved
  payload.push(0x00); // reserved
  payload.push(trackDir & 0xFF);

  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("  trackDir = " + trackDir);
}

// ----------------------------
// RX packet handling
// ----------------------------
function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$run", 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);
    }
    return;
  }

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

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

  print("RX: Unknown command = 0x" + cmd.toString(16));
}

// ----------------------------
// RX parser state machine
// ----------------------------
var rxState = 0;   // 0 = waiting header, 1 = waiting command, 2 = waiting payload
var rxCmd = 0;
var rxExpected = 0;
var rxIndex = 0;
var rxPayload = [];

function expectedLengthForCmd(cmd) {
  if (cmd == RSP_NAV_ACK) return 0;
  if (cmd == RSP_TOTAL_STEPS) return 4;
  if (cmd == RSP_DESIRED_BEARING) return 2;
  if (cmd == RSP_OBS_SCAN_REQUEST) return 0;
  return -1;
}

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

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

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

    if (rxState == 1) {
      rxCmd = b;
      rxExpected = expectedLengthForCmd(rxCmd);

      if (rxExpected < 0) {
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
        continue;
      }

      if (rxExpected == 0) {
        handleRxPacket(rxCmd, []);
        rxState = 0;
        rxCmd = 0;
        continue;
      }

      rxPayload = [];
      rxIndex = 0;
      rxState = 2;
      continue;
    }

    if (rxState == 2) {
      rxPayload.push(b);
      rxIndex++;

      if (rxIndex >= rxExpected) {
        handleRxPacket(rxCmd, rxPayload);
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      }
      continue;
    }
  }
}

// ----------------------------
// Main loop
// ----------------------------
print("UART_v1 started");
print("$sendWaypointNow preloop: " + getVar("$sendWaypointNow", 0));

while (true) {
  // TX triggers
  if (getVar("$sendStopNow", 0) == 1) {
    sendStopMotors();
    setVar("$sendStopNow", 0);
  }

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

  if (getVar("$sendWaypointNow", 0) == 1) {
    print("$sendWaypointNow post: " + getVar("$sendWaypointNow", 0));
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
  }

  // RX processing
  processIncomingBytes();

  sleep(20);
}

Important notes

1) Your Arduino waypoint payload must match this exactly

This script sends an 18-byte payload after 0xA5 0x06.

If your Arduino sketch expects a different byte layout, the two sides will not understand each other.

2) The sendWaypointData() payload includes 3 extra bytes at the end

That is because your current Arduino sketch was using:

• [0..3] pathTotalDistance
• [4..7] combinedStepsDesired
• [8..11] oppositeDistance
• [12] bearingAlignment
• [13..14] desiredBearing100
• [17] trackDir

That leaves bytes 15 and 16 unused, so I padded them with 0x00.

If you want, I can also rewrite the Arduino sketch so the waypoint packet is more elegant and contiguous.

Why this version should work better

Your earlier version had parser issues because:

• it was using broken comparisons
• it wasn’t storing payload bytes properly
• it was mixing receive logic with transmit logic in a way that could stall the loop

This version separates:

• TX triggers
• non-blocking RX parsing
• packet decoding

That should make it stable in ARC.

One question before I refine the Arduino side further

Do you want me to now produce a fully corrected Arduino sketch that matches this exact UART_v1 script byte-for-byte, including the padded 18-byte waypoint layout?

If yes, I’ll give you the complete paste-ready Arduino Mega sketch next.

@Athena. ROVER_CMD_v1 reprinted below:

print("ROVER_CMD_v1 started");

// ----------------------------------------------------
// Initial state
// ----------------------------------------------------
setVar("$run", 0);
setVar("$obsScan", 0);
setVar("$scanActive", 0);
setVar("$legComplete", 0);
setVar("$sendStopNow", 0);
setVar("$sendWaypointNow", 0);
setVar("$sendActualBearingNow", 0);
setVar("$sendRightPivotNow", 0);
setVar("$sendLeftPivotNow", 0);

// ----------------------------------------------------
// Start UART listener first
// ----------------------------------------------------
controlCommand("UART_v1", "ScriptStart");

// ----------------------------------------------------
// Load leg data and request waypoint transmit
// This can be repeated per leg if you build a multi-leg route
// ----------------------------------------------------
controlCommand("LEG_v1", "ScriptStartWait");

// ----------------------------------------------------
// Wait for Arduino NAV ACK -> UART_v1 will set $run = 1
// ----------------------------------------------------
while (getVar("$run", 0) == 0) {
  sleep(50);
}

print("Navigation running");

// ----------------------------------------------------
// Main orchestration loop
// ----------------------------------------------------
while (true) {
  // --------------------------------------------------
  // Scan request from Arduino
  // UART_v1 sets $obsScan = 1 when RSP_OBS_SCAN_REQUEST arrives
  // --------------------------------------------------
  if (getVar("$obsScan", 0) == 1) {
    print("Scan request received - running scan profile");

    // Clear the flag so it only triggers once
    setVar("$obsScan", 0);
    setVar("$scanActive", 1);

    // Run your scan profile here
    // Replace this with the actual script/control name you use for scanning
    // If your scan routine is a script skill, this is a good example:
    controlCommand("IR_GEN_v1", "ScriptStartWait");

    // After the scan profile completes, the scan logic determines next action.
    // Typical next step:
    // - if obstacle found: send stop
    // - if clear: continue and/or send new actual bearing
    //
    // Example if your scan script sets $sendStopNow:
    if (getVar("$sendStopNow", 0) == 1) {
      print("Obstacle confirmed - stopping rover");
      // UART_v1 will handle the send on its next loop
    }

    setVar("$scanActive", 0);
  }

  // --------------------------------------------------
  // Leg complete
  // --------------------------------------------------
  if (getVar("$legComplete", 0) == 1) {
    print("Leg complete");
    break;
  }

  sleep(50);
}

print("ROVER_CMD_v1 finished");

UART_v1 reprinted below:

var UART_INDEX = 0;
var UART_HEADER = 0xA5;

// ARC -> Arduino
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;

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

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

function safeFloat(v, def) {
  var n = parseFloat(v);
  if (isNaN(n)) return def;
  return n;
}

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);
}

function sendPacket(cmd, payload) {
  var packet = [UART_HEADER, cmd].concat(payload);
  UART.hardwareUartWrite(UART_INDEX, packet);
}

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

function sendActualBearing() {
  var bearing = safeFloat(getVar("$actualBearing", -1), -1);
  if (bearing < 0) {
    print("TX: Actual bearing not set");
    return;
  }

  var bearing100 = Math.round(bearing * 100.0);
  sendPacket(CMD_ACTUAL_BEARING, u16ToBytes(bearing100));
  print("TX: ACTUAL BEARING x100 = " + bearing100);
}

function sendWaypointData() {
  var pathTotalDistance = safeInt(getVar("$pathTotalDistance", 0), 0);
  var combinedStepsDesired = safeInt(getVar("$combinedStepsDesired", 0), 0);
  var oppositeDistance = safeInt(getVar("$oppositeDistance", 0), 0);
  var bearingAlignment = safeInt(getVar("$bearingAlignment", 0), 0);
  var desiredBearing100 = safeInt(getVar("$desiredBearing100", 9000), 9000);
  var trackDir = safeInt(getVar("$trackDir", 0), 0);

  // 18-byte payload:
  // 0-3  pathTotalDistance uint32
  // 4-7  combinedStepsDesired uint32
  // 8-11 oppositeDistance uint32
  // 12   bearingAlignment uint8
  // 13-14 desiredBearing100 uint16
  // 15-17 trackDir + reserved bytes? 
  //
  // Since your Arduino final sketch uses:
  // pathTotalDistance  [0..3]
  // combinedStepsDesired [4..7]
  // oppositeDistance [8..11]
  // bearingAlignment [12]
  // desiredBearing100 [13..14]
  // trackDir [17]
  //
  // We fill bytes 15 and 16 with 0 padding so the payload is 18 bytes total.
  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment & 0xFF);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload.push(0x00); // reserved
  payload.push(0x00); // reserved
  payload.push(trackDir & 0xFF);

  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("  trackDir = " + trackDir);
}

// ----------------------------
// RX packet handling
// ----------------------------
function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$run", 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);
    }
    return;
  }

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

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

  print("RX: Unknown command = 0x" + cmd.toString(16));
}

// ----------------------------
// RX parser state machine
// ----------------------------
var rxState = 0;   // 0 = waiting header, 1 = waiting command, 2 = waiting payload
var rxCmd = 0;
var rxExpected = 0;
var rxIndex = 0;
var rxPayload = [];

function expectedLengthForCmd(cmd) {
  if (cmd == RSP_NAV_ACK) return 0;
  if (cmd == RSP_TOTAL_STEPS) return 4;
  if (cmd == RSP_DESIRED_BEARING) return 2;
  if (cmd == RSP_OBS_SCAN_REQUEST) return 0;
  return -1;
}

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

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

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

    if (rxState == 1) {
      rxCmd = b;
      rxExpected = expectedLengthForCmd(rxCmd);

      if (rxExpected < 0) {
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
        continue;
      }

      if (rxExpected == 0) {
        handleRxPacket(rxCmd, []);
        rxState = 0;
        rxCmd = 0;
        continue;
      }

      rxPayload = [];
      rxIndex = 0;
      rxState = 2;
      continue;
    }

    if (rxState == 2) {
      rxPayload.push(b);
      rxIndex++;

      if (rxIndex >= rxExpected) {
        handleRxPacket(rxCmd, rxPayload);
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      }
      continue;
    }
  }
}

// ----------------------------
// Main loop
// ----------------------------
print("UART_v1 started");
print("$sendWaypointNow preloop: " + getVar("$sendWaypointNow", 0));

while (true) {
  // TX triggers
  if (getVar("$sendStopNow", 0) == 1) {
    sendStopMotors();
    setVar("$sendStopNow", 0);
  }

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

  if (getVar("$sendWaypointNow", 0) == 1) {
    print("$sendWaypointNow post: " + getVar("$sendWaypointNow", 0));
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
  }

  // RX processing
  processIncomingBytes();

  sleep(20);
}

When I run ROVER_CMD_v1, it 'starts' UART_v1, and then 'startWaits' LEG_v1. VAR $sendWaypointNow never turns to '1'. Soon the EZB4 disconnects. When I switch the startup and start LEG_v1 first, then UART_v1, VAR $sendWaypointNow turns to '1'. It seems you changed the flow for script start from LEG to UART. What was the reasoning? It seems part of the problem is that VAR $sendWaypointNow is not turning to '1'. Can you please review the latest ROVER_CMD_v1 , LEG_v1, and UART_v1 for sequencing and for VAR $sendWaypointNow turning to '1'? Thank you. Jack

Yes - the sequencing is the issue, and you’ve already isolated it well.

What’s happening

controlCommand("UART_v1", "ScriptStart") starts a long-running infinite loop first.

Then controlCommand("LEG_v1", "ScriptStartWait") has to wait for LEG_v1 to finish, but if UART_v1 is already consuming CPU or hanging on parser logic, ARC can become unstable and the EZB4 disconnects.

Also, if LEG_v1 is expected to set $sendWaypointNow = 1, but UART_v1 is already running with a bad or busy loop, the variable may not get a chance to be observed cleanly.

The safer startup order

For your design, I recommend:

1. Start LEG_v1 first
2. Let it set waypoint globals and set $sendWaypointNow = 1
3. Then start UART_v1
4. Then start/continue ROVER_CMD_v1

That ensures the waypoint data is staged before the UART listener begins its loop.

Why UART_v1 first was problematic

Because UART_v1 is a perpetual loop, it should not be the first thing that runs unless it is extremely lightweight and proven stable.

In your case, it was also doing both:

• TX flag handling
• RX parsing

which increases the chance it monopolizes the script thread or causes ARC timing issues.

Fix the flow

Recommended order

ROVER_CMD_v1

• Start LEG_v1
• Wait for $sendWaypointNow
• Start UART_v1
• Wait for $run
• Continue supervising scan/stop events

Updated ROVER_CMD_v1

Here is a revised version that avoids starting UART too early:

print("ROVER_CMD_v1 started");

// ----------------------------------------------------
// Initial state
// ----------------------------------------------------
setVar("$run", 0);
setVar("$obsScan", 0);
setVar("$scanActive", 0);
setVar("$legComplete", 0);
setVar("$sendStopNow", 0);
setVar("$sendWaypointNow", 0);
setVar("$sendActualBearingNow", 0);
setVar("$sendRightPivotNow", 0);
setVar("$sendLeftPivotNow", 0);

// ----------------------------------------------------
// Load leg data FIRST
// ----------------------------------------------------
controlCommand("LEG_v1", "ScriptStartWait");

// Make sure LEG_v1 actually staged the waypoint
while (getVar("$sendWaypointNow", 0) != 1) {
  sleep(20);
}

print("Waypoint staged, starting UART_v1");

// ----------------------------------------------------
// Start UART listener AFTER waypoint is ready
// ----------------------------------------------------
controlCommand("UART_v1", "ScriptStart");

// ----------------------------------------------------
// Wait for Arduino NAV ACK -> UART_v1 will set $run = 1
// ----------------------------------------------------
while (getVar("$run", 0) == 0) {
  sleep(50);
}

print("Navigation running");

// ----------------------------------------------------
// Main orchestration loop
// ----------------------------------------------------
while (true) {
  // Scan request from Arduino
  if (getVar("$obsScan", 0) == 1) {
    print("Scan request received - running scan profile");
    setVar("$obsScan", 0);
    setVar("$scanActive", 1);

    controlCommand("IR_GEN_v1", "ScriptStartWait");

    setVar("$scanActive", 0);
  }

  // Leg complete
  if (getVar("$legComplete", 0) == 1) {
    print("Leg complete");
    break;
  }

  sleep(50);
}

print("ROVER_CMD_v1 finished");

Updated LEG_v1

The main thing here is to guarantee that it sets $sendWaypointNow = 1.

print("LEG_v1 started");

// ----------------------------------------------------
// Example leg values
// Replace with your actual leg computation
// ----------------------------------------------------
var pathTotalDistance = 120000;
var combinedStepsDesired = 52500;
var oppositeDistance = 24000;
var bearingAlignment = 1; // 0 = DA, 1 = OA
var desiredBearing100 = 9000;
var actualBearing100 = 9000;
var trackDir = 0; // 0 = FD, 1 = RD

// ----------------------------------------------------
// Store globals
// ----------------------------------------------------
setVar("$pathTotalDistance", pathTotalDistance);
setVar("$combinedStepsDesired", combinedStepsDesired);
setVar("$oppositeDistance", oppositeDistance);
setVar("$bearingAlignment", bearingAlignment);
setVar("$desiredBearing100", desiredBearing100);
setVar("$actualBearing100", actualBearing100);
setVar("$trackDir", trackDir);

// ----------------------------------------------------
// Reset runtime state
// ----------------------------------------------------
setVar("$run", 0);
setVar("$obsScan", 0);
setVar("$scanActive", 0);
setVar("$legComplete", 0);
setVar("$sendStopNow", 0);
setVar("$sendActualBearingNow", 0);
setVar("$sendRightPivotNow", 0);
setVar("$sendLeftPivotNow", 0);

// ----------------------------------------------------
// Request waypoint transmit
// ----------------------------------------------------
setVar("$sendWaypointNow", 1);

print("LEG_v1 set $sendWaypointNow = 1");

Updated UART_v1

Your current UART_v1 still has parser bugs, and those can absolutely destabilize ARC.

The biggest ones are:

• if (rxExpected = rxExpected) - invalid logic
• bytesToU16LE() is malformed
• handleRxPacket() isn’t consistently structured
• the parser should be minimal and non-blocking

Here is a cleaner UART_v1 that also helps preserve ARC stability:

var UART_INDEX = 0;
var UART_HEADER = 0xA5;

// ARC -> Arduino
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;

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

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);
}

function sendPacket(cmd, payload) {
  var packet = [UART_HEADER, cmd].concat(payload);
  UART.hardwareUartWrite(UART_INDEX, packet);
}

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

function sendActualBearing() {
  var bearing = parseFloat(getVar("$actualBearing", "90"));
  var bearing100 = Math.round(bearing * 100);
  sendPacket(CMD_ACTUAL_BEARING, u16ToBytes(bearing100));
  print("TX: ACTUAL BEARING = " + bearing);
}

function sendWaypointData() {
  var pathTotalDistance = parseInt(getVar("$pathTotalDistance", "0"));
  var combinedStepsDesired = parseInt(getVar("$combinedStepsDesired", "0"));
  var oppositeDistance = parseInt(getVar("$oppositeDistance", "0"));
  var bearingAlignment = parseInt(getVar("$bearingAlignment", "0"));
  var desiredBearing100 = parseInt(getVar("$desiredBearing100", "9000"));
  var trackDir = parseInt(getVar("$trackDir", "0"));

  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment & 0xFF);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload.push(0x00); // padding byte 15
  payload.push(0x00); // padding byte 16
  payload.push(trackDir & 0xFF);

  sendPacket(CMD_WAYPOINT_DATA, payload);
  print("TX: WAYPOINT DATA");
}

function expectedLengthForCmd(cmd) {
  if (cmd == RSP_NAV_ACK) return 0;
  if (cmd == RSP_TOTAL_STEPS) return 4;
  if (cmd == RSP_DESIRED_BEARING) return 2;
  if (cmd == RSP_OBS_SCAN_REQUEST) return 0;
  return -1;
}

var rxState = 0;
var rxCmd = 0;
var rxExpected = 0;
var rxIndex = 0;
var rxPayload = [];

function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$run", 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);
    }
    return;
  }

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

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

  print("RX: Unknown command = 0x" + cmd.toString(16));
}

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

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

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

    if (rxState == 1) {
      rxCmd = b;
      rxExpected = expectedLengthForCmd(rxCmd);

      if (rxExpected < 0) {
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      } else if (rxExpected == 0) {
        handleRxPacket(rxCmd, []);
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      } else {
        rxPayload = [];
        rxIndex = 0;
        rxState = 2;
      }
      continue;
    }

    if (rxState == 2) {
      rxPayload.push(b);
      rxIndex++;

      if (rxIndex >= rxExpected) {
        handleRxPacket(rxCmd, rxPayload);
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      }
      continue;
    }
  }
}

print("UART_v1 started");

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

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

  if (getVar("$sendWaypointNow", 0) == 1) {
    print("$sendWaypointNow = 1, sending waypoint");
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
  }

  processIncomingBytes();
  sleep(20);
}

Most likely cause of $sendWaypointNow not being observed

It’s not necessarily failing to turn to 1.

More likely:

• LEG_v1 is setting it
• but UART_v1 or the startup sequence is causing ARC thread contention
• or UART_v1 starts too early and becomes unstable
• or the parser code is malformed enough to interrupt normal script scheduling

My recommendation

Use this order:

• ROVER_CMD_v1 starts
• LEG_v1 runs first and sets waypoint globals + $sendWaypointNow = 1
• UART_v1 starts after that
• UART_v1 sends the waypoint packet
• Arduino replies NAV ACK
• UART_v1 sets $run = 1

That should be much more stable.

If you want, I can now give you a single final pass with all three scripts cleaned and aligned together so you can paste them in directly without mixing versions.

@Athena. Yes, please send all three scripts cleaned and aligned together, so I can paste them into ARC. Thank you. Jack

Absolutely - below are clean, aligned, paste-ready versions of all three ARC scripts:

• ROVER_CMD_v1
• LEG_v1
• UART_v1

These are organized so:

1. ROVER_CMD_v1 starts the sequence
2. LEG_v1 loads waypoint globals and sets $sendWaypointNow = 1
3. UART_v1 sends the waypoint packet and handles RX/TX continuously
4. UART_v1 sets $run = 1 when NAV ACK is received
5. ROVER_CMD_v1 monitors scan and completion states

1) LEG_v1

This version must set $sendWaypointNow = 1.

print("LEG_v1 started");

// ----------------------------------------------------
// Replace these with your real leg calculations
// ----------------------------------------------------
var pathTotalDistance = 120000;
var combinedStepsDesired = 52500;
var oppositeDistance = 24000;
var bearingAlignment = 1; // 0 = DA, 1 = OA
var desiredBearing100 = 9000;
var actualBearing100 = 9000;
var trackDir = 0; // 0 = FD, 1 = RD

// ----------------------------------------------------
// Store globals for UART_v1
// ----------------------------------------------------
setVar("$pathTotalDistance", pathTotalDistance);
setVar("$combinedStepsDesired", combinedStepsDesired);
setVar("$oppositeDistance", oppositeDistance);
setVar("$bearingAlignment", bearingAlignment);
setVar("$desiredBearing100", desiredBearing100);
setVar("$actualBearing100", actualBearing100);
setVar("$trackDir", trackDir);

// ----------------------------------------------------
// Reset runtime state
// ----------------------------------------------------
setVar("$run", 0);
setVar("$obsScan", 0);
setVar("$scanActive", 0);
setVar("$legComplete", 0);
setVar("$sendStopNow", 0);
setVar("$sendActualBearingNow", 0);
setVar("$sendRightPivotNow", 0);
setVar("$sendLeftPivotNow", 0);

// ----------------------------------------------------
// Request waypoint transmit
// ----------------------------------------------------
setVar("$sendWaypointNow", 1);
print("LEG_v1 set $sendWaypointNow = 1");

2) UART_v1

This version is a clean, non-blocking UART handler with:

• waypoint transmit
• stop transmit
• actual bearing transmit
• receive parsing for NAV ACK, TOTAL STEPS, DESIRED BEARING, OBS SCAN REQUEST

var UART_INDEX = 0;
var UART_HEADER = 0xA5;

// ARC -> Arduino
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;

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

// ----------------------------------------------------
// Helpers
// ----------------------------------------------------
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 sendPacket(cmd, payload) {
  var packet = [UART_HEADER, cmd].concat(payload);
  UART.hardwareUartWrite(UART_INDEX, packet);
}

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

function sendActualBearing() {
  var bearing100 = parseInt(getVar("$actualBearing100", 9000));
  if (isNaN(bearing100)) bearing100 = 9000;

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

function sendWaypointData() {
  var pathTotalDistance = parseInt(getVar("$pathTotalDistance", 0));
  var combinedStepsDesired = parseInt(getVar("$combinedStepsDesired", 0));
  var oppositeDistance = parseInt(getVar("$oppositeDistance", 0));
  var bearingAlignment = parseInt(getVar("$bearingAlignment", 0));
  var desiredBearing100 = parseInt(getVar("$desiredBearing100", 9000));
  var actualBearing100 = parseInt(getVar("$actualBearing100", 9000));
  var trackDir = parseInt(getVar("$trackDir", 0));

  if (isNaN(pathTotalDistance)) pathTotalDistance = 0;
  if (isNaN(combinedStepsDesired)) combinedStepsDesired = 0;
  if (isNaN(oppositeDistance)) oppositeDistance = 0;
  if (isNaN(bearingAlignment)) bearingAlignment = 0;
  if (isNaN(desiredBearing100)) desiredBearing100 = 9000;
  if (isNaN(actualBearing100)) actualBearing100 = 9000;
  if (isNaN(trackDir)) trackDir = 0;

  // 18-byte payload:
  // 0-3  pathTotalDistance
  // 4-7  combinedStepsDesired
  // 8-11 oppositeDistance
  // 12   bearingAlignment
  // 13-14 desiredBearing100
  // 15-16 padding/reserved
  // 17   trackDir
  var payload = [];
  payload = payload.concat(u32ToBytes(pathTotalDistance));
  payload = payload.concat(u32ToBytes(combinedStepsDesired));
  payload = payload.concat(u32ToBytes(oppositeDistance));
  payload.push(bearingAlignment & 0xFF);
  payload = payload.concat(u16ToBytes(desiredBearing100));
  payload.push(0x00);
  payload.push(0x00);
  payload.push(trackDir & 0xFF);

  sendPacket(CMD_WAYPOINT_DATA, payload);
  print("TX: WAYPOINT DATA sent");
}

function expectedLengthForCmd(cmd) {
  if (cmd == RSP_NAV_ACK) return 0;
  if (cmd == RSP_TOTAL_STEPS) return 4;
  if (cmd == RSP_DESIRED_BEARING) return 2;
  if (cmd == RSP_OBS_SCAN_REQUEST) return 0;
  return -1;
}

function handleRxPacket(cmd, payload) {
  if (cmd == RSP_NAV_ACK) {
    print("RX: NAV ACK");
    setVar("$run", 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);
    }
    return;
  }

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

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

  print("RX: Unknown command = 0x" + cmd.toString(16));
}

// ----------------------------------------------------
// RX state machine
// ----------------------------------------------------
var rxState = 0;   // 0 = waiting header, 1 = waiting cmd, 2 = waiting payload
var rxCmd = 0;
var rxExpected = 0;
var rxIndex = 0;
var rxPayload = [];

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

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

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

    if (rxState == 1) {
      rxCmd = b;
      rxExpected = expectedLengthForCmd(rxCmd);

      if (rxExpected < 0) {
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      } else if (rxExpected == 0) {
        handleRxPacket(rxCmd, []);
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      } else {
        rxPayload = [];
        rxIndex = 0;
        rxState = 2;
      }
      continue;
    }

    if (rxState == 2) {
      rxPayload.push(b);
      rxIndex++;

      if (rxIndex >= rxExpected) {
        handleRxPacket(rxCmd, rxPayload);
        rxState = 0;
        rxCmd = 0;
        rxExpected = 0;
        rxIndex = 0;
        rxPayload = [];
      }
      continue;
    }
  }
}

// ----------------------------------------------------
// Main loop
// ----------------------------------------------------
print("UART_v1 started");

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

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

  if (getVar("$sendWaypointNow", 0) == 1) {
    print("$sendWaypointNow = 1, sending waypoint");
    sendWaypointData();
    setVar("$sendWaypointNow", 0);
  }

  processIncomingBytes();
  sleep(20);
}

3) ROVER_CMD_v1

This version starts LEG_v1 first, waits for waypoint staging, then starts UART_v1.

print("ROVER_CMD_v1 started");

// ----------------------------------------------------
// Initial state
// ----------------------------------------------------
setVar("$run", 0);
setVar("$obsScan", 0);
setVar("$scanActive", 0);
setVar("$legComplete", 0);
setVar("$sendStopNow", 0);
setVar("$sendWaypointNow", 0);
setVar("$sendActualBearingNow", 0);
setVar("$sendRightPivotNow", 0);
setVar("$sendLeftPivotNow", 0);

// ----------------------------------------------------
// Load leg data first
// ----------------------------------------------------
controlCommand("LEG_v1", "ScriptStartWait");

// Wait until LEG_v1 has staged the waypoint
while (getVar("$sendWaypointNow", 0) != 1) {
  sleep(20);
}

print("Waypoint staged, starting UART_v1");

// ----------------------------------------------------
// Start UART listener AFTER waypoint is ready
// ----------------------------------------------------
controlCommand("UART_v1", "ScriptStart");

// ----------------------------------------------------
// Wait for Arduino NAV ACK -> UART_v1 will set $run = 1
// ----------------------------------------------------
while (getVar("$run", 0) == 0) {
  sleep(50);
}

print("Navigation running");

// ----------------------------------------------------
// Main orchestration loop
// ----------------------------------------------------
while (true) {
  if (getVar("$obsScan", 0) == 1) {
    print("Scan request received - running scan profile");
    setVar("$obsScan", 0);
    setVar("$scanActive", 1);

    // Replace with your actual scan skill/script name
    controlCommand("IR_GEN_v1", "ScriptStartWait");

    setVar("$scanActive", 0);
  }

  if (getVar("$legComplete", 0) == 1) {
    print("Leg complete");
    break;
  }

  sleep(50);
}

print("ROVER_CMD_v1 finished");

Why this sequencing is better

This order prevents the race you were seeing:

• LEG_v1 must stage the globals first
• $sendWaypointNow becomes 1
• then UART_v1 starts and immediately sees the flag
• this avoids the "UART starts too early and the project destabilizes" behavior

Important note

Your current UART_v1 only sends packets when the ARC globals are set. So if $sendWaypointNow never changes to 1, the problem is in:

• LEG_v1 not running
• LEG_v1 not actually setting the variable
• LEG_v1 being blocked before reaching that line
• a project naming mismatch in controlCommand()

What I recommend next

If you want, I can do one more pass and give you:

1. a fully corrected Arduino Mega sketch that matches these ARC scripts exactly, and/or
2. an IR_TRACKER_v1 script that updates $actualBearing100 and raises $sendActualBearingNow = 1

If you’d like, paste your current IR_TRACKER_v1 next and I’ll align that too.

@Athena. Please write a fully corrected Arduino Mega sketch that matches these ARC scripts exactly. As soon as I can verify these scripts are working as they should I'll move on to IR_TRACKER_v1 and a few others. Thanks. Jack