AVR Freaks

Serial2.available()

fails at times since I am receiving response from a public network after some delay.

----

I mean: Serial.available() does not fail.

It will show received characters even after an buffer overflow. But it clears when all characters from the buffer are read.

But there is only this one flag and the overrun of the internal buffer is not signaled to the user.

If 100 bytes are transfered, Serial2.available is set.

But if you do not clear the buffer with Serial.read() not more than 64 bytes are reported by Serial.available();

The other 36 bytes are lost. You have to read at least 36 bytes within the time the 100 bytes come in to get all.

So:  Serial.availabe() is not the problem, it only seems to be, because it could not signal the lost bytes, when the buffer is full.

Better seen by example:  This is a little bit changed code from Arduino.cc (which -i think -  is misleading)

int incomingByte = 0;   // for incoming serial data

void setup() {
        Serial.begin(115200);     // opens serial port
}

void loop() {
static int i=1;
        // send data only when you receive data:    (my comment: do not send the datat)
        if (Serial.available() > 0) {
                // read the incoming byte:
                incomingByte = Serial.read();

                // say what you got:
                Serial.print("\nI received: #"); Serial.print(i++); Serial.print(" ");
                Serial.write(incomingByte);
        }
}

Start the serial monitor and print:

12345678901234567890

20 characters plus CrLF are displayed - that is ok.

Now build a line with 100 characters:

1234567890123 .... 90

then you will see, that NOT all 100 characters are received.

This is what happend:

First line: received characters, second line: output from Serial.print()

Well, all 100 characters (plus crlf) are transfered, but Serial.available only "sees" about  73 characters because of an internal buffer overflow.

Serial.available works correct until the buffer of 64 bytes is full. Reading SOME bytes, when the buffer is filled will extend the number of received bytes to 73, but 27 bytes are lost.

Try this:

int incomingByte = 0;   // for incoming serial data

void setup() {
  Serial.begin(115200);     // opens serial port, sets data rate to 9600 bps
  delay(1000);
  Serial.println("Give me some input...");
}


char mybuffer[110];
void loop() {
  static int i = 1;
  unsigned long start;

  while (1) {
    start = millis();
    while (!Serial.available()); // Wait for 1. byte
    
    while ((millis() - start) < 10) {
      if (Serial.available()) {
        mybuffer[i++] = Serial.read();
        start = millis();
      }
    }
    for (int j=1; j<i; j++)  { Serial.print(j); Serial.print(" "); Serial.println(mybuffer[j]); }
    i = 1;
  }
}

Now you get all 102 bytes.

Here i wait for the first character.

Then i store all received characters from the Serial.buffer into my own  buffer until a "character-free-time" of 10 ms occure.

After that i start the output.

Conclusion: Be very careful to do some output when receiving characters.

When in doubt: Do not output anything until you are sure the transmission ended.