SERCOM UART: available() unzuverlässig in Timeout-Schleife

International Deutsch
1

Hallo zusammen,
ich hoffe, jemand hat eine Idee. Ich nutze auf einem Arduino Nano 33 IoT (SAMD21) eine UART über SERCOM und habe ein Problem mit available().

Ich initialisiere die UART so:

Uart MySerial(&sercom1, 12, 11, SERCOM_RX_PAD_3, UART_TX_PAD_0);

void SERCOM1_Handler() {
  MySerial.IrqHandler();
}

void setup() {
  Serial.begin(9600);
  while (!Serial);
  Serial.println("Restart");

  MySerial.begin(9600, SERIAL_8N1);
}

void loop() {
  getData();
}

Wenn ich einfach nur abfrage, ob Daten da sind, funktioniert es:

void getData() {
  if (MySerial.available()) {
    // ... lesen und verarbeiten
  }
}

Sobald ich aber auf Daten mit einem Timeout warten will, wird es unzuverlässig. Bedeutet, das das available() teilweise niemals true (>0) wird:

void getData() {
  unsigned long T = millis();
  do {
    if ((millis() - T) > 10) {
      Serial.println("Time out");
      return;
    }
  } while (!MySerial.available());

  // ... lesen und verarbeiten
}

Wenn ich den Timeout Zeit erhöhe, wird die Ausfallrate höher.

Das Gegenstück sendet alle 100 ms genau 2 Bytes bei 9600 Baud, daher sollte es kein Overflow sein.

Hat einer von euch ggf. eine Idee woher der Fehler kommt?

2

Dann passt da was nicht.

Versuchs doch mal so:

void getData()
{
  static uint32_t myMillis=0;
  int x = mySerial.available();

  if (x > 0)
  {
    uint32_t myTime = millis();
    Serial.print(myTime - myMillis);
    Serial.print(F(" ms Laufzeit  # Inhalt: "));
    Serial.print(x);
    Serial.println(F(" Bytes"));

    while (x--)
    { mySerial.read(); }

    myMillis = myTime;
  }
}
3

Baudrate 9600 heißt, daß 9600 Bit pro Sekunde gesendet werden. Ein Byte hat 8 Bit. Dazu kommen im besten Fall 1 Start und 1 Stop Bit. Das sind dann 10 Bit pro Byte. Das sind dann ca 1 Byte pro ms.
Ich weiß jetzt nicht wie oft die Funktion getData() aufgerufen wird.
Also wieder mal ungenügende Infos und nur ein Bruchstücks eines nicht lauffähigen Sketches.
Grüße Uwe

4

Danke euch beiden für die Rückmeldung und die Hilfe.

Der eigentliche Fehler lag letztlich in meinem eigenen Code:
Ich hatte einen Fehler im Checksummen-Vergleich und in manchen Fällen wurden zwei Antworten quasi „zusammen“ empfangen. Dadurch kam es zu falschen Checksummen und es sah so aus, als ob die Daten verloren gehen würden.

Unabhängig davon noch ein Hinweis für alle, die ähnliche Probleme haben:

Der Arduino-SAMD-Serial-Treiber wertet die UART-Fehlerflags (Framing, Parity, Overflow) standardmäßig nicht aus. Wenn man sporadische Empfangsprobleme hat, lohnt es sich, den SERCOM-Status zu prüfen.

Mit folgendem kleinen Workaround kann man sich die Fehler anzeigen lassen:

bool sercomUsartHasError(SercomUsart* usart,
                         bool clearFlags = true,
                         uint16_t* outStatus = nullptr)
{
  uint16_t status = usart->STATUS.reg;

  const uint16_t mask =
      SERCOM_USART_STATUS_FERR |
      SERCOM_USART_STATUS_PERR |
      SERCOM_USART_STATUS_BUFOVF;

  if (outStatus) *outStatus = status;

  if (status & mask) {
    if (clearFlags) {
      usart->STATUS.reg = mask; // write-1-to-clear
    }
    return true;
  }
  return false;
}

Beispiel für die Nutzung:

uint16_t st;

if (sercomUsartHasError(&SERCOM1->USART, true, &st)) {
  Serial.print("UART Fehler, STATUS=0x");
  Serial.println(st, HEX);
}

Vielleicht hilft das ja jemandem, der ähnliche Timing- oder Empfangsprobleme mit SERCOM/UART hat.

5

Den Du nicht gezeigt hast.
Und mit einem vollkommen unsinngem Schnipsel um die Ecke gekommen bist.