Zeiten für einen Serial print

[Edward M. (ingrimmsch)]

Liebe Gemeinde,

ich habe in den letzten Tagen mit einem Arduino und einem Oszilloskop 
die Zeiten für bestimmte Operationen des Mikrocontrollers gemessen, um 
ein besseres Gefühl für die entsprechende Effizienz zu bekommen.

Um dies zu erreichen habe ich vor den entsprechenden Operationen einen 
Pin auf high gesetzt und ihn danach wieder auf low abfallen lassen. Die 
entsprechenden Zeiten habe ich mit meinem 1054z aufgezeichnet.

Gestern Abend wollte ich das gleiche dann noch für den "Serial.println" 
command machen...ich kann mir die Ergebnisse nur nicht so ganz erklären.
Wie im Graph zu erkennen, ist die Baudrate von 115200 bei bis zu 60 
Chars langsamer als die Baudrate von 9600. Erst danach wird die hohe 
Baudrate zu einem Vorteil.

Mir will einfach keine vernünftige Lösung dafür einfallen..

Hat einer von euch eine Idee oder gar die Lösung? :D

[Rufus Τ. F. (rufus)]

Nun, offensichtlich gibt es einen Teil von "serial.println", der 
komplett unabhängig von der Baudrate ist.

Sieh Dir doch einfach mal die Sourcen davon an, die sind im 
Arduino-Paket enthalten.

[Thomas W. (diddl)]

Edward M. schrieb:
> Gestern Abend wollte ich das gleiche dann noch für den "Serial.println"
> command machen...ich kann mir die Ergebnisse nur nicht so ganz erklären.
> Wie im Graph zu erkennen, ist die Baudrate von 115200 bei bis zu 60
> Chars langsamer als die Baudrate von 9600. Erst danach wird die hohe
> Baudrate zu einem Vorteil.

Serial.println schreibt in einen Buffer.
Eine Interrupt Routine sendet dann die Zeichen im Buffer.

Es dauert immer gleich lang, die Zeichen in den Buffer zu schreiben.
Egal wie schnell die Daten danach gesendet werden.


Natürlich nur solange, wie die Bufferlänge nicht überschritten wird.
Denn wenn kein Platz mehr im Buffer vorhanden ist, dann wartet println() 
darauf, bis Zeichen versendet worden sind, und wieder Platz im Buffer 
ist.

[Einer K. (Gast)]

Thomas W. schrieb:
> dann wartet println()
> darauf, bis Zeichen versendet worden sind,
Ich stimme vollumfänglich zu.

[Fred Feuerstein (Gast)]

Edward M. schrieb:
> ein besseres Gefühl für die entsprechende Effizienz zu bekommen.

Um es mal pauchal auszudrücken: die Effizienz (in Termen von
Geschwindigkeit) ist in einer Arduino-Firmware-Umgebung (um
das Wort "Betriebssystem" zu vermeiden) schlichtweg gesagt
unter aller Kanone.

Hilfestellung: richtig programmieren und schon ist alles gut.

[Einer K. (Gast)]

Fred Feuerstein schrieb:
> schlichtweg gesagt
> unter aller Kanone.

Von Arduino wird die ganz normale AVR Toolchain genutzt.

Und von daher ist die gleiche Performance zu erreichen, wie unter den 
andren IDEs(bzw. make) auch.

Es ist also eher dein Beitrag, welcher "unter aller Kanone" ist.

[Stefan S. (chiefeinherjar)]

Edward M. schrieb:
> Um dies zu erreichen habe ich vor den entsprechenden Operationen einen
> Pin auf high gesetzt und ihn danach wieder auf low abfallen lassen.

Wenn du die Funktion DigitalWrite() nutzt, solltest du wohl bedenken, 
dass auch diese einen großen Overhead hat und unabhängig von der 
Baudrate zur Gesamtdauer beiträgt.

[Edward M. (ingrimmsch)]

Thomas W. schrieb:
> Serial.println schreibt in einen Buffer.
> Eine Interrupt Routine sendet dann die Zeichen im Buffer.
>
> Es dauert immer gleich lang, die Zeichen in den Buffer zu schreiben.
> Egal wie schnell die Daten danach gesendet werden.

Super, dass hört sich gut an :)

Fred Feuerstein schrieb:
> Um es mal pauchal auszudrücken: die Effizienz (in Termen von
> Geschwindigkeit) ist in einer Arduino-Firmware-Umgebung (um
> das Wort "Betriebssystem" zu vermeiden) schlichtweg gesagt
> unter aller Kanone.
>
> Hilfestellung: richtig programmieren und schon ist alles gut.

Nunja, ich nutze auch Atmel Studio, aber gerade für kurze Projekte 
bietet es sich einfach an, die Arduino IDE zu nutzen.

Stefan S. schrieb:
> Wenn du die Funktion DigitalWrite() nutzt, solltest du wohl bedenken,
> dass auch diese einen großen Overhead hat und unabhängig von der
> Baudrate zur Gesamtdauer beiträgt.

Die erste Messung war nur die reine an-/abstiegszeit dieser Funktion. 
Diese wurde aus allen folgenden Messungen natürlich subtrahiert :)

[Walter (Gast)]

Thomas W. schrieb:
> Serial.println schreibt in einen Buffer.

und aus der Messung kann man vermuten dass er maximal 60 Bytes groß ist

[Wolfgang (Gast)]

Fred Feuerstein schrieb:
> Um es mal pauchal auszudrücken: die Effizienz (in Termen von
> Geschwindigkeit) ist in einer Arduino-Firmware-Umgebung (um
> das Wort "Betriebssystem" zu vermeiden) schlichtweg gesagt
> unter aller Kanone.

An der Effizienz der seriellen Übertragung wirst du mit derartigen 
"klugen" Sprüchen nichts ändern können. Bei 9600 Bd beträgt die 
Übertragungsdauer für ein Byte nun mal rund 1ms. Sobald der Sendepuffer 
gefüllt ist, ist dies der limitierende Faktor. Und da der Pufferspeicher 
begrenzt ist, läufst du ab einer gewissen zu übertragenden Datenmenge 
immer in diese Grenze.

Erkläre bitte mal, wo da in deinen Augen die Arduino-Firmware-Umgebung 
begrenzend wirkt.

[Manfred (Gast)]

Edward M. schrieb:
> Um dies zu erreichen habe ich vor den entsprechenden Operationen einen
> Pin auf high gesetzt und ihn danach wieder auf low abfallen lassen. Die
> entsprechenden Zeiten habe ich mit meinem 1054z aufgezeichnet.

Das mache ich mir einfacher:

unsigned long StartTime = millis(); // debug

diverse Serial.print( ....

Serial.print(millis()-StartTime);
Serial.println(" ms");

Gerade die Tage habe ich anstatt Serial.print meine ms mal ins 
LC-Display geschrieben: Es ist egal, ob ein Terminal an der 
Schnittstelle angeschlossen oder das USB-Kabel ab ist.