Serial communication with Arduino Uno in hexadecimal, and monitoring response with serial monitor

Question

I have a project where I need to send an array of hex bytes from an Arduino Uno to a third party device through serial communication, the device performs an action, and replies with an array of bytes, also in hex after a short time (+-500ms).

A third-party USART USB interface is used to record the response from the third-party device to a computer, with a Bluetooth link between the third-party device TX and the USART RX. The Arduino TX and third-party device RX are wired.

Now the problematic bit:

My project requires that the Arduino also captures the response from the third-party device, processes the response, and depending on the value, triggers different outputs (LED's).

I also need the ability to debug the Arduino, to make sure that the hex values that it receives are being processed correctly and that the output is accordingly triggered.

The code that I currently have (compiling, but not working as I anticipate it) is hown below:

byte one_shot_FAST[] = {0xAA, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x02, 0x23};

int IncomingByte = 0;

uint8_t q1 = 0;
uint8_t q2 = 0;
uint16_t qtot = 0;
int qVal = 0;
int qValMax = 65535;

const int triggerPin = 2;
int triggerState = LOW;


void setup() {

 Serial.begin(19200);
 pinMode(triggerPin, INPUT);

     Serial.println("<Arduino is ready>");
 
}

void loop() {

triggerState = digitalRead(triggerPin);

if (triggerState == HIGH){
  Serial.write(&one_shot_FAST[0], sizeof(one_shot_FAST));
  //while(!Serial.available());
  IncomingByte = Serial.read();

for (int i=0; i<13; i++) {
  while(!Serial.available()); //wait for character
  IncomingByte = Serial.read();
  Serial.println(IncomingByte,HEX);
delay(10);
}

I expect the following response: AA 00 00 22 00 03 00 00 03 2B 01 E1 35

but I get a string of "#" and a square block after each "#"

This is what the schematic looks like:

Answer 1

Let us dissect your question:

I am trying to send a HEX line to a device via serial communication, and read the response back...

You don't say what device, one has to assume the said device is neither the Arduino you talk about later nor a computer.

...while monitoring the transaction.

This is simply not possible unless you have a multipoint serial link (RS485, for instance). If you want to monitor a serial link you need to do it from either side or use a special piece of equipment (hardware sniffer) or implement your own sniffer using a couple of additional serial ports.

... but I am not reading the correct transmission and any response through USB.

If your Arduino is connected to your computer via USB, in the general scenario (which you might not be but you did not care to explain), you're already using the Arduino's hardware serial port for that purpose (serial monitor on your computer).

So, where is "the device" connected to your Arduino? If you mean you have connected it to pins 0 and 1 while you keep the Arduino connected to your computer through USB then we have found your problem.

From the official documentation:

On Uno, Nano, Mini, and Mega, pins 0 and 1 are used for communication with the computer. Connecting anything to these pins can interfere with that communication, including causing failed uploads to the board.

Finally, you say:

...although an external USART adapter does show the correct response.

Apparently, by that you mean you are connecting your "device" to the computer using a USB-to-serial adapter while the Arduino is not intervening at all. I guess you mean you have a terminal program like PuTTY or RealTerm for Windows or Minicom on Linux, you open a session to the virtual serial port (created when you connect your cable), type the command and press intro. If that's the case, be aware that the command you're writing with your Arduino is not terminated with CR or LF. Does your device require line termination? One can only guess...

Now with your code. Not knowing what you want to do, or with a lot of gaps filled by guessing, it's not really easy to give you much feedback.

But this line seems particularly enigmatic:

Serial.write(&one_shot_FAST[0], sizeof(one_shot_FAST));

With one_shot_FAST being a byte array (for all purposes a pointer), so when you use &one_shot_FAST[0] you're asking to write the address that the first element of the array occupies in memory. I'm not sure of what is your idea about this, but I think you might want to drop the & to send the actual bytes on your command instead.

There are other odd things in your code: you write to the port and instantly (likely even before the data leaves for the TX buffer) you read one byte. I imagine that would result in Serial.read() giving back -1.

EDIT: I have tested your code and the write part (obviously I don't have the hardware to answer on the command) works fine. The square and dashes you see are most likely due to the fact that you are using the Arduino serial console, which is trying to display HEX values bigger than 127 as ASCII so it doesn't know how to display them. If you use a terminal able to display HEX the command will be correctly displayed. And, you have of course the problem of trying to connect more than two devices to the bus.