Wie funktioniert XON/XOFF

[Philipp (Gast)]

Guten Morgen,

ich habe den Auftrag bekommen mich mal mit XON/XOFF zu beschäftigen und 
durch meine Internetsuche habe ich auch schon herausgefunden wofür es 
gut ist dennoch habe ich nicht wirklich etwas gefunden was mir bei der 
Programmierung helfen könnte. Mir ist unklar ob XON/XOFF eine feste 
Funktion ist oder ob man sie einbinden muss.

Ich benutze den ATmega 128 und möchte mit einem PC kommunizieren.

Ich bin für jede art von Info über XON/XOFF sehr dankbar.

MFG Philipp

[johnny.m (Gast)]

Hast Du auch da schon geschaut:
http://de.wikipedia.org/wiki/Xon#Software-Flusskontrolle.2C_Software-Handshake.2C_Software-Protokoll_oder_X-ON.2FX-OFF
Da steht eigentlich ausreichend genau beschrieben, wie es 
funktioniert...

[Philipp (Gast)]

Ja da war ich auch schon aber es hat mir nicht sehr viel geholfen. Somit 
wusste ich zwar wofür XON/XOFF benötigt wird aber nicht wie man es in 
seinem Programm implementiert!

Könnte mir jemand ein Beispielprogramm in Verbindung mit XON/XOFF 
zukommen lassen?

[Günter R. (galileo14)]

Philipp wrote:
> Ja da war ich auch schon aber es hat mir nicht sehr viel geholfen. Somit
> wusste ich zwar wofür XON/XOFF benötigt wird aber nicht wie man es in
> seinem Programm implementiert!
>
> Könnte mir jemand ein Beispielprogramm in Verbindung mit XON/XOFF
> zukommen lassen?

Du mußt in Deinem Programm einen Empfangspuffer einrichten, in den die 
empfangenen Zeichen zwischengespeichert werden (z.B. ein Fifo); dort 
mußt Du den "Füllgrad" beobachten, durch eine geeignete Funktion, die 
Dir meldet, wenn der Puffer z.B. zu 95% gefüllt ist; sobald diese 
Situation auftritt, sendest Du das X-Off-Zeichen zum Sender; dieser 
reagiert darauf und unterbindet weiteres Senden, solange, bis Du das 
X-On-Zeichen sendest. Das tust Du z.B. dann, wenn der Füllgrad 80% 
beträgt (hängt aber stark von der Applikation ab). Zu beachten ist die 
Reaktionsgeschwindigkeit des Senders bzw. wieviele Zeichen er noch 
senden könnte, wenn Du X-Off abgeschickt hast. Insofern muß ein 
Empfangspuffer immer noch Platz für einige Zeichen haben, auch wenn das 
X-Off abgeschickt wurde; je nach Sendegeschwindigkeit und Puffergröße 
muß also dieser "95%-Wert" angepaßt werden: je kleiner der Puffer und je 
höher die Bitrate und je größer die Reaktionszeit des Senders, umso 
kleiner dieser Prozentwert.

[Karl H. (kbuchegg)]

Da ist doch nichts schweres daran:

Wenn dein Programm möchte, dass die Gegenstelle
aufhört zu senden, dann schickt es das Zeichen XOFF
über die Leitung. Wenn dein Programm dann wieder
Zeichen aufnehmen kann, schickt es XON.

Das einzige worauf du aufpassen musst, ist dass nach
dem Senden von XOFF noch ein/zwie Zeichen kommen
können (je nachdem wie schnell die Gegenstelle auf
den XOFF reagiert).

Mehr ist das nicht.


Bsp:
Dein Programm hat einen Input-Buffer in dem es zunächst
die empfangenen Zeichen zwischenspeichert. Jetzt ist
dein Programm anderweitig beschäftig und hat keine
Zeit die Zeichen aus diesem Buffer abzuholen ->
der Buffer füllt sich zusehends. Ist der Buffer
zu 80% gefüllt, so schickt die Empfangsroutine
einen XOFF. Daraufhin stellt die Gegenstelle das Senden
ein und dein Programm läuft nicht Gefahr, dass der Buffer
überläuft. (Dazu implementiert man die Empfangsroutine
am besten in eine ISR, die beim Empfang eines Zeichens
aufgerufen wird).

Irgendwann hat dann dein Hauptprogramm wieder Zeit die
empfangenen Zeichen abzuholen. Die Funktion die ein Zeichen
aus dem Buffer holt, überprüft auch noch, ob ein XOFF gesendet
wurde und wenn die Bufferauslastung durch das Abholen von Zeichen
wieder unter 10% gesunken ist, sendet sie einen XON an die
Gegenstelle.

Selbes Spielchen in der umgekehrten Richtung: Wenn die
Empfangsroutine einen XOFF empfängt, heist das, das die
Gegenstelle möchte, dass dein Programm das Senden einstellt.
Kriegt deine Empfangsroutine einen XOFF, dann setzt sie ein
Flag, das der Senderoutine verbietet das nächste Zeichen
zu senden. Empfängt sie ein XON, dann setzt sie dieses
Flag wieder zurück.

Wie das im Detail implementiert wird, hängt stark von deiner
momentanen Architektur ab. Das Prinzip ist aber immer:
Du redest mit deinem Freund. Plötzlich ruft dein Freund:
"Warte mal" (XOFF), macht irgendwas anderes und wenn er wieder
aufnahmebereit ist, ruft er dir zu: "OK, weiter" (XON)

[Philipp (Gast)]

Soweit so gut aber macht er das automatisch? Also führt er automatisch 
den XOFF befehl aus wenn der Puffer voll ist? Wenn ja kann man dem 
Programm sagen das wenn der Puffer zu 50% voll ist das er dann das XOFF 
zeichen sendet?

Du hast auch gesagt "(Dazu implementiert man die Empfangsroutine
am besten in eine ISR, die beim Empfang eines Zeichens
aufgerufen wird)" kannst du mir das vielleicht etwas genauer erklären?

[Philipp (Gast)]

Mein hauptsächliches Problem besteht darin das ich nicht weiß WIE ich 
ein XON/XOFF Zeichen sende also die Syntax für diese Funktion.

[OliverSo (Gast)]

>Soweit so gut aber macht er das automatisch?
...
>Mein hauptsächliches Problem besteht darin das ich nicht weiß WIE ich
>ein XON/XOFF Zeichen sende also die Syntax für diese Funktion.

Es gibt keine "Syntax" für diese Funktion.
Das wirst du komplett selber programmieren müssen.

Oliver

[Christoph db1uq K. (christoph_kessler)]

Das sind einfach zwei ASCII-Steuerzichen, wie es im Wikipedia-Artikel 
steht, die werden genau wie jeder andere Buchstabe gesendet:

"DC1 (oft als X-ON bezeichnet, engl. für Transmission ON, 
Zeichencodierung 11hex, PC-Tastatur: Strg-Q) und
DC3 (oft als X-OFF bezeichnet, engl. für Transmission OFF, 
Zeichencodierung 13hex PC-Tastatur: Strg-S)."

Ascii-Tabelle hier:
http://de.wikipedia.org/wiki/ASCII

[Philipp (Gast)]

Vielen Dank erstmal für die schnellen Antworten sie haben mir echt 
geholfen jetzt wäre nur noch ein Beispiel-Programm das I-Töpfelchen!

Mit freundlichen Grüßen und Dank

Philipp

[Karl H. (kbuchegg)]

Philipp wrote:
> Soweit so gut aber macht er das automatisch? Also führt er automatisch
> den XOFF befehl aus wenn der Puffer voll ist? Wenn ja kann man dem
> Programm sagen das wenn der Puffer zu 50% voll ist das er dann das XOFF
> zeichen sendet?
>
> Du hast auch gesagt "(Dazu implementiert man die Empfangsroutine
> am besten in eine ISR, die beim Empfang eines Zeichens
> aufgerufen wird)" kannst du mir das vielleicht etwas genauer erklären?

Dann solltest du dich mal grundsätzlich mit der Funktion
der UART beschäftigen:
* Wie sendet man Zeichen, welche Möglichkeiten gibt es dafür
* Wie empfängt man Zeichen, welche Möglichkeiten gibt es dafür

In beiden Fällen gibt es die Straightforward Sede und
Empfangsfunktionen, die in das Hauptprogramm eingebaut
werden.
Die etwas ausgefuchstere Version ist es, wenn beides
über Interrupts gesteuert abläuft. Und genau die brauchst
du.

Schau dir mal die UART Library von Peter Fleury an (danach
googeln). Wenn ich mich richtig erinnere arbeitet die
über Interrupts.

[OliverSo (Gast)]

Oder die procyon avrlib. Die bietet interrupts und buffer, nur eben kein 
xon/xoff. Das musst du dann noch selber dranbasteln.

Oliver

[Karl H. (kbuchegg)]

Allerdings:
Wenn man eine bestehende Lib studieren muss, ist es wohl
besser das ganze neu zu schreiben. Bis man raus hat, wo mann
eingreifen muss, hat man das auch schon neu gemacht und dann
weiss man was man hat :-)

Eine bestehende Lib studieren, wie die Dinge gemacht werden
ist aber immer eine gute Idee.

[Philipp (Gast)]

Hat nicht jemand ein beispiel Programm für mich?

[Karl H. (kbuchegg)]

Christoph Db1uq wrote:
> Das sind einfach zwei ASCII-Steuerzichen, wie es im Wikipedia-Artikel
> steht, die werden genau wie jeder andere Buchstabe gesendet

Wobei ich mich immer schon mal gefragt habe:
Wie wird das gehandhabt?
Angenommen mein Gegenüber schickt einen XOFF, möchte
also von mir nicht 'belästigt' werden. Jetzt komm
ich aber selber in Zeit/Speichernot und will ihm einen
XOFF schicken. Darf ich das dann? Sein XOFF steht ja immer
noch und eigentlich besteht ja Sendeverbot.

Mir ist schon klar, dass die Antwort logischerweise
nur 'ja, ich darf senden' lauten kann. Aber
eigenartigerweise wird diese Thematik nie irgendwo
erwähnt :-)

Das Senden von XON, XOFF muss immer den kurzen Weg
durch alle Buffer nehmen und auch ein bestehender
XOFF von der Gegenstelle wird ignoriert. Ansonsten
könnte man sich leicht in einen Deadlock hineinmanövrieren.

[OliverSo (Gast)]

>Darf ich das dann? Sein XOFF steht ja immer
>noch und eigentlich besteht ja Sendeverbot.

Es besteht nur ein Sendeverbot für Daten. xon/xoff selber sind aber 
keine Daten, sondern Steuerzeichen.

So würde ich das interpretieren ...
Das braucht aber heutzutage eh keiner mehr.

Oliver

[Karl H. (kbuchegg)]

Philipp wrote:
> Hat nicht jemand ein beispiel Programm für mich?


Sag blos du hast in den vergangenen Stunden die 3 Variablen
und 5 Zeilen zusätzlichen Code nicht hingekriegt?

Eine (ungetestete) Implementierung einer gebufferten UART
Empfangseinheit ohne XON/XOFF könnte zb. so aussehen:

#define BUFFER_LEN 20

char Buffer[BUFFER_LEN];

volatile uint8_t NextWriteBufferPos;
volatile uint8_t NextReadBufferPos;
volatile uint8_t CharsInBuffer;

void SendImmidate( char c )
{
    while (!(UCSRA & (1<<UDRE)))
        ;

    UDR = c;
}

// wird aufgerufen, wenn ein Zeichen von der UART empfangen wurde
ISR( USART_RXC_vect )
{
  Buffer[NextBufferPos] = UDR;

  NextWriteBufferPos = NextWriteBufferPos + 1 ) % BUFFER_LEN;
  CharsInBuffer++;
}

char GetUartChar()
{
  if( CharsInBuffer == 0 )
      return 0;

  char NextChar = Buffer[NextReadBufferPos];
  NextReadBufferPos = ( NextReadBufferPos + 1 ) % BUFFER_LEN;
  CharsInBuffer--;

  return NextChar;
}

Wird ein Zeichen empfangen, wird die Interrupt Funktion aufgerufen
welche das Zeichen in einen Buffer stellt.
Das Hauptprogramm nutzt die Funktion GetUartChar() um sich die
Zeichen dann in aller Gemütsruhe aus diesem Buffer zu holen.

Soweit so gut.
Jetzt kann es natürlich passieren, dass das Hauptprogramm die
Zeichen nicht abholt. D.h. die Empfangsfunktion prüft,
ob der Buffer sich füllt und wenn eine kritische Grenze
überschritten wird, dann schickt sie an die Gegenstelle einen
XOFF.
Die Aufhebung erfolgt in der Zeichen-Abhol-Funktion. Wurde
ein Xoff gesendet und sinkt der Füllgrad wieder unter eine
Grenze, dann wird mit einem XON der Gegenstelle wieder
signalisiert, dass sie weitersenden darf.
Und genau das wird straightforward, so wie es in einigen
Postings vorher und auf dem Wiki Artikel erklärt wurde,
dazu implementiert.

#define XON  0x11
#define XOFF 0x13

#define BUFFER_LEN 20
#define HIGH_WATER  15
#define LOW_WATER  5

char Buffer[BUFFER_LEN];

volatile uint8_t NextWriteBufferPos;
volatile uint8_t NextReadBufferPos;
volatile uint8_t CharsInBuffer;
volatile uint8_t XoffSent;

void SendImmidate( char c )
{
    while (!(UCSRA & (1<<UDRE)))
        ;

    UDR = c;
}

// wird aufgerufen, wenn ein Zeichen von der UART empfangen wurde
ISR( USART_RXC_vect )
{
  Buffer[NextBufferPos] = UDR;

  NextWriteBufferPos = NextWriteBufferPos + 1 ) % BUFFER_LEN;
  CharsInBuffer++;

  if( CharsInBuffer == HIGH_WATER ) {
      SendImmidate( XOFF );
      XoffSent = 1;
  }
}

char GetUartChar()
{
  if( CharsInBuffer == 0 )
      return 0;

  char NextChar = Buffer[NextReadBufferPos];
  NextReadBufferPos = ( NextReadBufferPos + 1 ) % BUFFER_LEN;
  CharsInBuffer--;

  if( XoffSent && CharsInBuffer < LOW_WATER ) {
      SendImmidiate( XON );
      XoffSent = 0;
  }

  return NextChar;
}

Die Sendeeinheit ist sogar noch einfacher:
In der Empfangsroutine wird zusätzlich noch überprüft
ob von der Gegenstelle ein XON oder XOFF gekommen ist.
Wenn ja wird einfach nur ein Flag gesetzt.
In der Zeichen-Sende-Funktion wird noch getestet, ob
das Senden zulässig ist, und fertig:

#define XON  0x11
#define XOFF 0x13

#define BUFFER_LEN 20
#define HIGH_WATER  15
#define LOW_WATER  5

char Buffer[BUFFER_LEN];

volatile uint8_t NextWriteBufferPos;
volatile uint8_t NextReadBufferPos;
volatile uint8_t CharsInBuffer;
volatile uint8_t XoffSent;
volatile uint8_t CanSend;

void SendImmidate( char c )
{
    while (!(UCSRA & (1<<UDRE)))
        ;

    UDR = c;
}

// wird aufgerufen, wenn ein Zeichen von der UART empfangen wurde
ISR( USART_RXC_vect )
{
  char c = UDR;

  if( c == XON ) {
      CanSend = 1;
      return;
  }
  if( c == XOFF ) {
      CanSend = 0;
      return;
  }
  
  Buffer[NextBufferPos] = UDR;

  NextWriteBufferPos = NextWriteBufferPos + 1 ) % BUFFER_LEN;
  CharsInBuffer++;

  if( CharsInBuffer == HIGH_WATER ) {
      SendImmidate( XOFF );
      XoffSent = 1;
  }
}

char GetUartChar()
{
  if( CharsInBuffer == 0 )
      return 0;

  char NextChar = Buffer[NextReadBufferPos];
  NextReadBufferPos = ( NextReadBufferPos + 1 ) % BUFFER_LEN;
  CharsInBuffer--;

  if( XoffSent && CharsInBuffer < LOW_WATER ) {
      SendImmidiate( XON );
      XoffSent = 0;
  }

  return NextChar;
}

void SendUartChar( char c )
{
    while( !CanSend )
        ;
    SendImmidate( c );
}