De Arduino-kern heeft een overdrachtsbuffer van 64 bytes. Tekens worden door de hardware uit die buffer gestuurd.

Als je veel tekens uit de serie schiet, worden de eerste 64 gewoon in die buffer geplaatst - bijna onmiddellijk.

Eenmaal die buffer is vol met je sketchblokken totdat de hardware een karakter heeft gestuurd om ruimte te maken.

Aangezien het direct verzendt vanaf het moment dat je het eerste karakter in de buffer plaatst, krijg je iets meer dan 64 bytes aan buffertijd (64 + het aantal dat is verzonden tegen de tijd dat de buffer volloopt).

Vanaf dat moment ben je volledig overgeleverd aan de baudrate die je hebt gekozen.

Aan om een ​​meer voorspelbare doorvoer te krijgen (en de snelheid te maximaliseren), moet u de Ardiuno-kern omzeilen en de UART-registers rechtstreeks manipuleren.

Majenko gaf al het goede antwoord: zodra de buffer vol is, valt alles uit elkaar (voor een tijdgevoelige applicatie).

Het is mogelijk om de seriële buffer voor je project te vergroten. In de toekomst, met een nieuwe Arduino-versie, ben je misschien vergeten dat je een bibliotheek hebt gewijzigd en dat het project niet meer zo goed werkt.

Ik wil erop wijzen dat je de usb seriële poort die zich in sommige microcontrollers en processors bevindt. Dat is geen echte seriële uart met een baudrate en een klokje, maar een usb CDC device.
Een atmega32u4 en de arm m0 + hebben zo'n usb CDC seriële poort.
De arduino leonardo, micro en pro micro gebruiken de atmega32u4.
De arduino zero, m0, mkr series gebruiken de arm m0 + processor.

Hoe zit het met deze getallen:

  NB_CHARS: Tijd (microsec) 1: 6.932 : 7.603: 8.06 [...] 99: 153100: 154101: 152 [...] 199: 1685200: 1624201: 1705  

Dat is met een arm m0 + processor. Ik heb dezelfde sketch gebruikt als jij, maar ik heb de Serial gewijzigd in SerialUSB .

Je "lange" vertraging is helemaal niet te lang.

Als je de doorvoer van het rechterdeel meet, heb je ongeveer 30 tekens verzonden in 2500 microseconden. Dit betekent dat de snelheid ruwweg (30 * 8 * 1.000.000) / 2500 is, wat 96.000 bits / sec is.

Het is iets minder dan 115.200 die u hebt opgegeven, maar seriële protocollen gebruiken servicebits, dus je zou in feite 8 moeten vervangen door 10. Dit geeft 120.000 baud wat binnen de meetfout valt.

Het linkerdeel is eigenlijk veel sneller dan je nodig had, maar zoals @Majenko terecht opmerkte , dit is te danken aan buffering. Blijkbaar kunt u de buffergrootte vergroten tot 256 bytes. Als u consistentie nodig heeft in plaats van maximale snelheid, kunt u in plaats daarvan de buffergrootte verkleinen.

Ten slotte moet u de prestaties testen in een realistisch scenario. In uw voorbeeld blijft u gegevens in een lus verzenden; Uiteraard vult u de buffer snel en loopt u tegen de snelheidslimiet aan. In het echte leven zou je lus waarschijnlijk wat invoer lezen, wat berekeningen uitvoeren en dan het resultaat verzenden. In dit geval zou u de buffer effectiever gebruiken.