USART Sende Problem - 168

ahja es ist ein 168iger

Ein Fehler:

   UBRR0H = ((16000000UL/(38400 * 16L)) >> 8);
   UBRR0L = (16000000UL/(38400 * 16L)) - 1;

Die Formel sollte in beiden Fällen bis auf das ">>8" gleich sein
(==>Makro verwenden!). Hat aber eher nichts mit deinem Problem zu tun.
Ansonsten finde ich dein Programm etwas wirr, weil du teilweise
Funktionen von hand implementierst, andererseits aber fertige
Funktionen benutzt bzw. Funktionen verwendest, die nicht in deinem
Quellcode vorkommen (sind die Teil der stdio.h?).

hallo,

ja das programm hab ich ja von menem restlichen programm ausgelagert
deswegen ein bisschen schlampig wollte sehen ob der fehler viel an
meinem restlichen programm liegt aber das war es auch nicht.

aber es wundert mich einfach wieso er den interrupt ein bzw 2 mal
ausführt, beim 2 mal wird der interrupt deaktivert ... wird aber wieder
aktiviert wenn in den puffer geschrieben wird... habe mir auch alle
register angeschaut vor dem interrupt und nachdem er wieder aktiviert
wird .. identisch :(

Also ich sehe da einiges unsauberes im Programm
rout,tin müssen nicht volatile sein
r_in & RMASK solltest du ersetzen durch module Arraygrösse bei 2^n wird
das dann auch ein AND ist aber wesentlich Fehlerunabhängiger
>return(r_in - r_out);
du willst doch mit Ringpuffer arbeiten? Da kann das auch negativ
werden!
In putchar und analog getchar machst du einfach r_out++;  sicher
maskierst du noch beim Zugriff aber das ist ...
besonders wenn man damit den Abstand im Ringpuffer bestimmen will.
(r_in - r_out)
Ich würde vorschlagen du räumst erstmal in deinem Programmcode mit
diesen Schlampigkeiten auf.
Der interrupt wird 2x ausgeführt aufgrund der Doppelpufferung.

so da is mal der code so wie ich ihn bei mir hab ohne meiner meinung
nach schlampigkeiten. das mit TX_BUF_MASK & tx_in find ich eig ganz
praktisch :)

das empfangen funktioniert auch einwandfrei nur halt beim senden wird
der interrupt nur 2 mal aufgerufen und dann nie wieder obwohl das
register auf empty steht und der interrupt auch aktiviert ist.

das uart_getc ist zu vergessen benutz es eh nicht geh da genau so über
einen interrupt..


uint8_t tx_buff[TX_BUF_SIZE];
uint8_t tx_in = 0;
uint8_t tx_out = 0;

uint8_t rn_buff[RN_BUF_SIZE];
uint8_t rn_in = 0;
uint8_t rn_out = 0;

/* Initialiesierung von Uart */
void uart_init(void){


  // Setzen der Baud Rate
  UBRR0H = (BAUD_RATE >> 8);
  UBRR0L = BAUD_RATE;

  //     (Empfänger)  |  (Sender)
  UCSR0B = (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);

  //     (    8 Bit Befehl   )
  UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);

  fdevopen(uart_putc, uart_getc);


}

/* Senden aus dem Puffer */
SIGNAL(SIG_USART_DATA){

  if(tx_in != tx_out)
    UDR0 = tx_buff[tx_out++ & TX_BUF_MASK];
  else
    /* Sendebuffer ist leer, UDRE Interrupt deaktivieren */
    UCSR0B &= ~(1<<UDRIE0);


}

/* Senden eines Zeichen */
void uart_putc(unsigned char c)
{
  //Warten bis platz im Zwischenspeicher frei wird
    while( (RN_BUF_MASK - tx_in - tx_out) < 1)
    ;

  tx_buff[TX_BUF_MASK & tx_in++] = c;

  UCSR0B |= 1<<UDRIE0;

}

1. du hast 2 volatile zu viel weggenommen
2.(RN_BUF_MASK - tx_in - tx_out)
Wie schon erwähnt du erhöhst unsauber (ohne zu maskieren)
die Zeichen gehen schneller in den Puffer als heraus d.h. z.B.
RN_BUF_MASK=31 tx_in=40 (da du nicht maskierst) txout=2
31-40-2=mit sicherheit <1
Hör mit diesem Schlampigkeiten auf oder wiederhole sie nicht noch wenn
du darauf hingewiesen wirst!

verwirr den armen nicht mit deinem volatile das ist meistens unwichtig.
aber wenn man ne variable volatile macht dann schadet es auch nicht,
kostet nur ein bisschen mehr rechenzeit. manche compiler erkennen sogar
selbst wann eine variable volatile sein muss und wann nicht. also zu
viele volatiles schaden nicht, verlängern nur die ausführzeit des
programms

31-40-2=mit sicherheit <1

wenn das kleiner 1 is soll er solange warten bis es >1 dann weis er ja
ob platz frei is oder nicht

ah ich bin schon ganz verwirrt kannst du das den nicht kurz hincoden
wie du es meinst ... steht grad total aufm schlauch

tx_out++ & TX_BUF_MASK

Müsste IMHO auch eher "++tx_out & TX_BUF_MASK" heissen.
(Der Übersicht wegen mache ich das gerne in zwei Zeilen.)

>RN_BUF_MASK - tx_in - tx_out

Dabei geht es doch "nur" darum, festzustellen, ob noch mindestens 1
Byte in den Puffer passt, oder?
"while (tx_in == tx_out);" sollte da sinnvoller sein, da die beiden
Variablen sowieo dauernd mit Puffergrösse-1 verundet werden.
Wolfram hat da schon ein schönes Rechenbeispiel geliefert.

>  wenn tx_in != tx_out     es gibt Platz im Buffer
>  wenn tx_in == tx_out     es gibt keinen Platz im Buffer

Da gibt es aber Start-Probleme: Im ersten Moment sind tx_in und tx_out
gleich (== 0 oder je nach Initialisierung).
Besser ist es, entweder die freien Plätze im Puffer oder die zu
sendenden Bytes zu zählen. Ist die Anzahl der freien Pufferplätze = 0,
ist er voll...
Ansonsten sollte man sich eine Funktion (oder Makro) ausdenken, das die
Anzahl der freien Speicherplätze errechnet:

l = ((tx_in>ty_out) ? (tx_in-tx_out) : (tx_out-tx_in))) & TX_BUF_MASK;

(könnte so funktionieren... ausm Ärmel geschüttelt).

Ist l<RN_BUF_MASK, dann ist (sollte noch) noch Platz vorhanden
(sein)...

ich weis jetzt nicht ob ich meinen code anders sehe als ihr aber meiner
meinung is es so das durch

tx_buff[TX_BUF_MASK & tx_in++] = c;

tx_in immer hochgezzählt wird und somit die gesamtanzahl der bytes die
in den Puffer geschrieben worden sind ausgelesen wird

tx_out wird immer hochgezählt wenn ein byte rausgeschrieben wurde

tx_in: 60
tx_out: 40

=> 20 Byte im puffer

puffer: 30

puffer - (tx_in - tx_out) => 10
=> 10 platz frei

 => fehler im porg das die klammer fählt

=>
//warte bedingung
while( (TX_BUF_MASK - (tx_in - tx_out)) < 1)
    ;



sehe ich das jetzt so richtig von meinem eigen prog oder sieht ihr das
anders

aber wie gesgat ich hab mehr das problem das er den interrtupt nicht
wieder auslöst er kommt also gar nich wieder da rein

/* Senden aus dem Puffer */
SIGNAL(SIG_USART_DATA){

  if(tx_in != tx_out)
    UDR0 = tx_buff[tx_out++ & TX_BUF_MASK];
  else
    /* Sendebuffer ist leer, UDRE Interrupt deaktivieren */
    UCSR0B &= ~(1<<UDRIE0);


}

>tx_in immer hochgezzählt wird und somit die gesamtanzahl der bytes >die
in den Puffer geschrieben worden sind ausgelesen wird
>tx_out wird immer hochgezählt wenn ein byte rausgeschrieben wurde

Gute Einwand, wenn tx_in unendlich groß werden könnte. Irgenwann gibt
es aber einen Überlauf, und dann ist tx_in definitiv (für eine gewisse
Zeit) kleiner als tx_out.

Ich meinte mit "aus dem Ärmel gschüttelt" die Berechnung (hab noch
nicht sooo oft mit "= ? :" gearbeitet).

stimmt da habt ihr recht ich schreib das schnell mal um so wie ihr es
machen würdet :)

while( (RN_BUF_MASK - tx_in - tx_out) < 1);
Hast du schonmal daüber nachgedacht was passiert wenn txin über läuft
31-0-255 was wird das für ein Datentyp? Ich habe da irgendwie leichte
Probleme. Also wie war das Es wird in den grössten verwendeten Datentyp
konvertiert. defines sind standardmäßig ohne Kennzeichnung int ?
Das heisst wir rechnen mit int 31-0-255=-224
Warum läßt du die Variable durchlaufen und hältst nicht in ihr den
direkten Pufferindex? Das würde auch die Fehlersuche sehr erleichtern.

so hab das mal angepasst sollte so jetzt sein oder? torzdem immer noch
das problem mit dem interrupt... :(


#include "uart.h"


uint8_t tx_buff[TX_BUF_SIZE];
uint8_t tx_in = 0;
volatile uint8_t tx_out = 0;

uint8_t rn_buff[RN_BUF_SIZE];
volatile uint8_t rn_in = 0;
uint8_t rn_out = 0;
uint8_t *rn_parameter[MESSAGE_BUF_SIZE];

uint8_t parameter = 0;
uint8_t temp_parameter = 0;
uint8_t temp = 0;

void uart_putc(unsigned char c);
uint8_t uart_getc();



/* Initialiesierung von Uart */
void uart_init(void){


  // Setzen der Baud Rate
  UBRR0H = (BAUD_RATE >> 8);
  UBRR0L = BAUD_RATE;

  //     (Empfänger)  |  (Sender)
  UCSR0B = (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0)| (1<<TXCIE0);

  //     (    8 Bit Befehl   )
  UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);

  fdevopen(uart_putc, uart_getc);


}


/* Senden aus dem Puffer */
SIGNAL(SIG_USART_DATA){

  if(tx_in != tx_out){
    tx_out = ( tx_out + 1 ) & TX_BUF_MASK;

    UDR0 = tx_buff[tx_out];
  }else
    /* Sendebuffer ist leer, UDRE Interrupt deaktivieren */
    UCSR0B &= ~(1<<UDRIE0);


}




/* Senden eines Zeichen */
void uart_putc(unsigned char c){

   uint8_t tmphead;

   tmphead = ( tx_in + 1 ) & TX_BUF_MASK;


   //Warten bis platz im Zwischenspeicher frei wird
    while( tmphead == tx_out )
      ;

    tx_buff[ tmphead ] = c;
    tx_in = tmphead;

    UCSR0B |= 1<<UDRIE0;

}

Hier mal zum Vergleich die Uartroutinen die ich verwende
(Mega16, 8Mhz bis 500kBit)

mich wundert des weil den ir löss ich ja eig aus und eig mach ich ja
alles richtig wird der ir nur 2 mal ausgelöst :(

also ich hab grad rumgespielt

das problem tritt durch das deaktivern und aktivern des interrupts
auf..

wenn ich ein belibiges zeichen sende und den interrupt laufen lasse
geht das ohne probleme sobald ich ihn aber deaktiver und wieder
aktivier wird er nicht mehr ausgeführt .. an was kann das liegen?


SIGNAL(SIG_USART_DATA){

  if(tx_in != tx_out){
    tx_out = ( tx_out + 1 ) & TX_BUF_MASK;

    UDR0 = tx_buff[tx_out];

  }else
    UDR0 = '.';
    //UCSR0B &= ~(1<<UDRIE0);


}

Sollte das:

    tx_out = ( tx_out + 1 ) & TX_BUF_MASK;
    UDR0 = tx_buff[tx_out];

nicht lieber andersherum stehen:

    UDR0 = tx_buff[tx_out];
    tx_out = ( tx_out + 1 ) & TX_BUF_MASK;

Übrigens müsste die Abfrage

RN_BUF_MASK - tx_in - tx_out

so funktionieren:

RN_BUF_MASK - ((tx_in - tx_out) & TX_BUF_MASK)

ne des funtz schon da ich auch am anfag um eins erhöhe hab nur noch das
dumme interrupt prob :(