Uart Buffer verwenden

[Michael (Gast)]

Hi,

ich stecke gerade etwas mit dem buffer der avrlib fest.

es kommt ein zeichen über uart0 rein, dann wird das zeichen in den 
buffer kopiert:

bufferAddToEnd(&uartRxBuffer[0], charIn);

und jetzt soll das zeichen wieder interruptgesteuert aus dem buffer an 
uart0 gesendet werden.

kann mir jemand helfen wie es weitergeht?

uartSendBuffer(0,???);

[Stefan B. (stefan)]

> bufferAddToEnd(&uartRxBuffer[0], charIn);
> uartSendBuffer(0,???);

Du meinst die Procyon AVRlib
http://www.mil.ufl.edu/~chrisarnold/components/microcontrollerBoard/AVR/avrlib/docs/html/uart_8c-source.html

Die gesuchte Funktion (Anhängen eines Zeichens an den zuvor 
eingerichteten Sendepuffer) wäre uartAddToTxBuffer(charIn)

> bufferAddToEnd(&uartRxBuffer[0], charIn);

Diese Konstruktion ist IMHO sehr ungewöhnlich. Ich würde vom 
Hauptprogramm aus den Empfangspuffer schön in Ruhe lassen. Normalerweise 
würde deine gesamte Abfrage (Emfangen und Echo zurücksenden) so aussehen

  {
    u08 charIn;
    if (uartReceiveByte(&charIn))
      uartAddToTxBuffer(charIn);
  }

[Michael (Gast)]

uartAddToTxBuffer(0, charIn);

ok, jetzt ist das zeichen im buffer.

wie wird der buffer jetzt gesendet?

[Michael (Gast)]

bei:

uartSendTxBuffer(0);
wird  \0\0\0\0 gesendet.

Es kommen aber Zeichen an.

[Stefan B. (stefan)]

Michael wrote:
> uartAddToTxBuffer(0, charIn);

Du hast meine Antwort nicht verstanden und bist dem Link nicht wirklich 
nachgegangen. Hättest du das gemacht, hättest du dort gesehen, wie die 
Funktion definiert ist:

// add byte to end of uart Tx buffer
u08 uartAddToTxBuffer(u08 data)
{
  //...
}

Schon die Zahl der Argumente in deinem Code passt nicht.

[Michael (Gast)]

bei mir ist das so definiert:

void uartAddToTxBuffer(u08 nUart, u08 data)
{
  bufferAddToEnd(&uartTxBuffer[nUart], data);
}

[Stefan B. (stefan)]

Das ist aus uart2.c, d.h. die Library mit zwei Puffern.
http://www.mil.ufl.edu/~chrisarnold/components/microcontrollerBoard/AVR/avrlib/docs/html/uart2_8c-source.html

// Description  : This is a UART driver for AVR-series processors with two
//                hardware UARTs such as the mega161 and mega128

nUart ist die Nummer des UARTs (0 oder 1)
data ist das zu sendende Zeichen (0x00 bis 0xFF)

#include "buffer.h"
#include "uart2.h"

//...

  {
     char *s = "Hello world!";

     uartInit();

     while(*s)
       uartAddToTxBuffer(0, *s++); // UART0 TX Buffer füllen

     uartSendTxBuffer(0);          // UART0 Senden einschalten
  }

//...

[Michael (Gast)]

Hi Stefan,

jetzt bin ich durch deine Hilfe schon etwas weiter.

Der buffer wird befüllt.

Aber das auslesen des buffers sollte anderst laufen.

Die Zeichen die über uart reinkommen sollen durchgeschleift werden, das 
heißt gleich wieder rausschicken auf die uart.

ohne buffer wäre das ja so:

1. Zeichen kommt rein   Zeichen = UDR1
2. Zeichen an uart      UDR0 = Zeichen

ich denke so soll man es nicht machen, wie mache ich das mit buffer?

1. uartAddToTxBuffer(0, Zeichen);
2.

mit uartSendTxBuffer(0); wir der buffer gesendet, aber aufruf in main 
kann doch zu oft, oder zu spät sein oder?

[Stefan B. (stefan)]

#define UART0 0
#define UART1 1

// ...
u08 TXaktiv;

  while(1)
  {
    u08 rxData;

    if (uartReceiveByte(UART1, &rxData))
    {
      uartAddToTxBuffer(UART0, rxData);
      TXaktiv++;
    }

    // irgendwann wenn z.B. genug Zeichen im TX-Puffer sind
    // TX starten
    if (TXaktiv >= 23)
      uartSendTxBuffer(UART0);

    // Anm.: Ich habe keine einfache Funktion gefunden, mit der 
    // man dieses interruptbasierte Senden aus dem Puffer nach
    // Wunsch stoppen kann. Man kann es wohl nur an schalten und
    // dann laufen lassen. Mehrfachaufruf schadet aber nicht.
  }

// ...

EDIT: Eine Alternative wäre TXaktiv++; wegzulassen und die if-Abfrage so 
zu machen, um den Mehrfachaufruf zu vermeiden.

    if (!TXaktiv)
    {
      uartSendTxBuffer(UART0);
      TXaktiv = 1;
    }

[Michael (Gast)]

wo setzt du TXaktiv auf 0

[Stefan B. (stefan)]

Das Hochzählen in Alternative 1 ist eigentlich Käse. Ich habe mir 
irgendwas aus den Fingern gesogen, um ein Beispiel zu haben, das einen 
Puffer halbwegs rechtfertigt.

Bei der Alternative 2 (ohne Hochzählen) wird TXaktiv bewusst nirgends 
zurückgesetzt. Das Senden ist einmal angestossen worden und läuft ab 
dann im Interrupt nebenher immer weiter. TXaktiv != 0 verhindert 
einfach, dass das Senden noch mal angestossen wird (wäre aber folgenlos, 
wenn es doch geschähe).

[Bernd bömer (Gast)]

Hallo,
ich arbeite auch mit dieser Lib und versuche mit einem ATMega128 ein 
String ("$BM,1666.123 m<CR>"aus 9..12 Zeichen(0.000 m ..1666.123 m) zu 
empfangen und daraus die Zahlen auf einem LC -Display daszustellen..
Wie kann ich das einlesen?
Mfg Bernd

[Stefan B. (stefan)]

Hilft meine Antwort in Beitrag "Re: Procyon AVRlib , wie kann ich hiermit eine String vom UA" 
nicht weiter?