readString doesn't work for Arduino nano every Serial1 as expected

Question

I'm trying to establish communication channel between two Arduino Nano Everys using Serial1. The attached code contains the COMM class, which is designed as a generic library, and the main loop. I'll describe the problem. May you help me in solving it?

For ease of configuration management the code was designed to run on two stations - RC and Machine, selected by a GPIO bit (txRxPin). The RC station transmits a string, then waits for the machine to receive it and respond.

The code runs successfully on hardware loopback. However, when I connect the two stations (crossing Rx to Tx, of course) I have a problem with the receive method - rxData. The data is not received on either side; furthermore, the readString line is stuck on the machine station but not on the RC station. I tried adding some delays without success. I tried to replace the command with the loop

rcRxBuffer = "";
while (available()) rcRxBuffer += char)Serial1.read();

It worked, but lost some characters.

The messages printed to the console: Machine side - initial:

Init started Init finished; station mode=machine station TP rxData 1

Machine side after RC reset (only once) - 57 iterations of the data:

TP rxData 2 8001|8001|8001|409 as received on machine from machine to rc as transmitted from machine

RC side

RC Transmission start at 55512 Transmitted from RC on RC: 8001|8001|8001|77 Error #78; loop time = 500 Communication in time #78/0 - no data; loop time = 500 TP loop RC 1

Code:

#define VERBOSE

#include <Arduino.h>
/*****************************************************/
#define txRxPin 15
class serialCommunication {
public:
  void begin();
  bool txData(String txStr);
  bool rxData(String &rxStr);
  bool available() {
    Serial1.available();
  }
} Comm;

void serialCommunication::begin() {
  Serial1.begin(19200);
  while (!Serial1)
    ;
}

bool serialCommunication::txData(String txStr) {
  if (Serial1.available())
    return false;
  digitalWrite(txRxPin, true);  // If RS485 - transciever to TX mode
  Serial1.print(txStr);
  Serial1.flush();
  digitalWrite(txRxPin, false);  // If RS485 - transciever to TX mode
  return true;
}

bool serialCommunication::rxData(String &rxStr) {
  if (!Serial1.available())
    return false;
  while (digitalRead(txRxPin))
    ;
  Serial.println("TP rxData 1");
  rxStr = Serial1.readString();
  Serial.println("TP rxData 2");
  return rxStr.length() > 0;
}
/*****************************************************/
/*************   Main program   **********************/
/*****************************************************/
#define txInterval 500
uint32_t timing;
bool stationType;  // low - machine, high - remote control mode
int commError, previousPacketCounter, packetCounter;
String announcement;

/*****************************************************/
void setup() {
  Serial.begin(9600);
  while (!Serial)
    ;
  Serial.println("Init started");

  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, false);

  Comm.begin();
  pinMode(txRxPin, INPUT);
  timing = millis();
  packetCounter = 0;
  commError = 0;
  previousPacketCounter = 0;

  stationType = digitalRead(txRxPin);
  announcement = stationType ? "remote control station" : "machine station";
  Serial.println("Init finished; station mode=" + announcement);
  delay(1000);
}
/*****************************************************/
void loop() {
  digitalWrite(LED_BUILTIN, true);
  if (stationType) {
Serial.println("TP loop RC 1");
    //******************** remote controller
    if ((millis() - timing) > txInterval) {
      Serial.println("\n\nRC Transmission start at " + String(millis() - timing));
      String packet = "8001|";
      packet += packet + packet + String(packetCounter++);  // create the packet
      if (!Comm.txData(packet))                             // Transmit the packet
        packetCounter--;                                    // The packet was not transmittedso retain its number
#ifdef VERBOSE
      Serial.println("Transmitted from RC on RC: " + packet);
      Serial.flush();
#endif

      // Receive machine reply
      long txTimer = millis();
      while ((millis() - txTimer) < 10)
        ;  // Seria;1 settling time
      while (!Comm.available() && ((millis() - txTimer) < txInterval))
        ;
Serial.println("Error #" + String(++commError) + "; loop time = " + String((millis() - txTimer)));
      String rcRxBuffer;
      bool rFlag = Comm.rxData(rcRxBuffer);
#ifdef VERBOSE
      if (!rFlag) {
        Serial.println("Communication timeout, error# " + String(commError) + "/" + String(rFlag) + " - no data; loop time = " + String((millis() - txTimer)));
        return;
      }
      commError = 0;
#endif
      Serial.println("Communication succeeded; rFlag=" + String(rFlag) + "; loop time = " + String((millis() - txTimer)));
      Serial.println("Data=<" + rcRxBuffer + ">");
      //      Serial.println(rcRxBuffer + " as received by RC; loop time = " + String(millis() - txTimer));
      Serial.flush();
    }
  } else {
    //******************** Machine Station
    String machineRxBuffer;
    if (Comm.rxData(machineRxBuffer)) {
      String reply = "from machine to rc ";  //checkRxStr(machineRxBuffer);
#ifdef VERBOSE
      Serial.println(machineRxBuffer + "\n as received on machine");
      Serial.println(reply + " as transmitted from machine");
#endif
      Comm.txData(reply);
    }
  }
  timing = millis();
  digitalWrite(LED_BUILTIN, true);
}

Answer 1

Well, the problem is with the READSTRING command. I've found the source code, and the method template is

int readString(char *buffer, int max_len, int terminator)

Meaning that on top of the buffer name, it needs also the max length and delimiter (it filters the \n out). I replaced the command with the following code segment. However, the string is received in two parts - the first character, then the rest of the strinb, whatever its length is.

bool rxData(String &rxStr, uint8_t rxSizeLim) {
  rxStr = "";
  while ((rxStr.length() < rxSizeLim) && (Serial1.available())) {
    int readch = Serial1.read();
    if (readch == terminator) {
      rxStr += '\0';
      break;
    }
    rxStr += (char)readch;
  }
  return rxStr.length() > 0;
}