Create an array. See the documentation for the command here: https://synthiam.com/Support/javascript-api/UART/hardwareUartWrite

It accepts either a single byte or an array of bytes. Here's an example...

UART.initHardwareUart(0, 9600);

UART.hardwareUartWrite(0, [0xff, 0xf0, 0x30]);

Here's information about what an array is: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

PS, your code could be written more efficiently like so...

while(true) {

  if (UART.hardwareUartAvailable(0) > 3) {

    var q = UART.hardwareUartRead(0, 4);  //read 4 bytes from the receive buffer
    var r = (q[1] * 256) + q[2];          //Multiply 2nd byte by 256 and add 3rd byte
    print("Distance(mm):" + r);       //print distance value
  }

  sleep(250);
}

Excellent! Thank you @DJ

I knew there had to be something I was missing for the first question! Sometimes I wish the JavaScript support section had proper syntax examples for newbs like me :D

Thanks for the code clean-up, I do need help from mentors such as yourself to help me make my code more efficient.

As for the second part of my question, I read somewhere that it's proper just to read everything into an array from the UART buffer, take what you need, and then read it again. You don't have to worry about flushing (clearing) the buffer. Is this true?

Don’t read everything because you might be in between packets. Take what you expect based on what’s available.

don’t flush the uart (ie re-init). That’s also gonna end up with half a packet.

I'll expand since i'm on my pc now.

A properly designed protocol has either

1. a consistent known packet length
2. a header that defines the packet length

*Note: There are some people who implement poor communication by using "termination". That means you send a bunch of characters and it is "terminated" with a specified token.

So if you are reading, the two examples I provided above allow you to know how much data to read.

1) Consistent known packet length I use the word consistent because it means the receiver ALWAYS knows the packet length. Although there could be an exception in the header that if a specific header value is sent, that means the next value is "the length of data". So you can mix the two together. The EZB protocol does that - but don't worry about it because it's beyond the scope of your question.

A consistent length means you know every packet is 2 bytes. So, therefore, you only need to read when there are MORE or EQUAL TO 2 bytes in the buffer.

// Are there at least two bytes available?
 if (UART.hardwareUartAvailable(0) >= 2) {

  // read 2 bytes from the buffer
  var q = UART.hardwareUartRead(0, 2);

 // Do something with the received data
}

2) Packet Header specifies data length This is when the transmitter has a specific header that specifies how much data is to follow. Funny enough, many protocols also include "parity" bytes when using TCP or even Bluetooth serial (haha). That's redundant and quite ridiculous, but software engineers get off by making things confusing. You know, the more confusing it is, the smarter the programmer was? (no but they think so).

Anyway, back on track. You never need a parity byte with tcp or Bluetooth serial because it's already built into the underlying communication protocol. Even with hardware UART, i wouldn't bother...

So if you designed a protocol and needed to transmit a variable length of data, you do this...

Transmitter

var str = "some random amount of data";

// write the amount of data we're gonna send
UART.hardwareUartWrite(0, str.length);

// now send the data
UART.hardwareUartWriteString(0, str);

Receiver

while (true) {

  var availableBytes = UART.hardwareUartAvailable(0);

  // must be more than one byte available because the packet length can't be 0
  if (availableBytes > 1) {

    // we have data so let's grab the header which tells us the packet length    
    var len = UART.hardwareUartRead(0, 1);
    
    // get all the data (it will block until all data is sent to ezb)
    var data = UART.hardwareUartReadString(0, len);
    
    // do something with data
  }
  
  sleep(100);
}

And here is the same thing above but with bytes rather than a string..

Transmitter

var str = [0xff, 0xfe, 0xfa, 0x35, 0xaf];

// write the amount of data we're gonna send
UART.hardwareUartWrite(0, str.length);

// now send the data
UART.hardwareUartWrite(0, str);

Receiver

while (true) {

  var availableBytes = UART.hardwareUartAvailable(0);

  // must be more than one byte available because the packet length can't be 0
  if (availableBytes > 1) {

    // we have data so let's grab the header which tells us the packet length    
    var len = UART.hardwareUartRead(0, 1);
    
    // get all the data (it will block until all data is sent to ezb)
    var data = UART.hardwareUartRead(0, len);
    
    // do something with data
  }
  
  sleep(100);
}

Thank you DJ for taking the time to answer and explain this question, it definitely helped!