ATMEGA32 USART sendet ein Zeichen zuviel

[Michael E. (micde)]

Hallo Zusammen,

bin gerade dabei eine USART Kommunikation (ATmega32) mit FIFO und durch 
Interrupts gesteuert einzurichten.
Funktioniert eigentlich recht gut. Nur, dass jedesmal nach Abschluss der 
Kommunikation ein 0xFF zusätzlich gesendet wird.
Dabei ist es egal ob die TX Routine mehrfach ausgeführt wird um den 
Puffer zu befüllen oder nicht.

In dem Beispiel unten möchte ich "Hallo Welt!" senden.

Die Ausgabe in hterm ist allerdings etwas anders (und ohne Hochkommas):
"Hallo Welt![0xFF]"

Das 0xFF in eckigen Klammern wird natürlich als ein einzelnes Zeichen 
dargestellt :)

Verwende ich eine nicht Interrupt gesteuerte Routine wie

for(i=0; i<8 ;i++)              //gibt maximal 16 Zeichen aus 
{                    
  if(data[i] == 0) break;        //Abbruch wenn Nullterminator entdeckt
  while( !( UCSRA & (1<<UDRE) ));      //warten bis "USART Data Register Empty" gesetzt ist
  UDR = data[i];
}

funktioniert das Senden ohne Fehler.

Entdeckt jemand von Euch wo sich der Denkfehler in der Routine unten 
befinden könnte?
Ich suche jetzt schon seit 2 Tagen. Bekomme das 0xFF am Ende einfach 
nicht weg :(

#ifndef F_CPU
#define F_CPU 14745600
#endif 

#define RX_BUFFER_SIZE  256
#define TX_BUFFER_SIZE  256

#include <avr/io.h>                  //Headerdatein einbinden
#include <string.h>                  
#include <avr/interrupt.h>
#include <stdbool.h>

//Deklarationen von Funktionen
void initialize(void);
void wait(unsigned int ms);
int TX(char data[TX_BUFFER_SIZE]);

int TX_free_size(void);


//Globale Variablen Deklarieren
unsigned int * volatile pt_1;

static unsigned char TX_Buffer[TX_BUFFER_SIZE];      //Puffer für Transmitting Data, 256 Byte
static unsigned char TX_Buffer_In;            //TX Puffer Position für Eingabe
static unsigned char TX_Buffer_Out;            //TX Puffer Position für Ausgabe
static bool TX_FULL;                  //TX Puffer voll



int main(void)
{
        initialize();

  while(TX("Hallo Welt!") != 0);
  while(1);
}
//------------------------------------------
//Funktionen
//------------------------------------------

//------------------------------------------
//Mikroprozessor initialisieren
//------------------------------------------
void initialize(void)
{
  //Port Einstellungen
  DDRD = 0b00100000;  //PD5 auf Ausgang
  DDRA = 0b11111111;  //PA auf Ausgang
  //USART Einstellungen
  UCSRB = (1<<RXEN) | (1<<TXEN);          //RX und TX einschalten
  UCSRC = (1<<URSEL)|(3<<UCSZ0);            //Asynchron, keine Parität, 1 Stoppbit, 8 Datenbits
  //UCSRC = 0b1000011;      //Asynchroner Modus, 8 Bit, keine Parität, 1 Stoppbit; URSEL setzen für Zugriff auf Baudrate
  UBRRH =  0;          //Achtung! Hängt von der Frequenz ab! 19,2kBaud eingestellt (U2X = 0!)
  UBRRL = 47;
  
  //Variablen initialisieren
  TX_Buffer_In = TX_Buffer_Out;  //Sendepuffer auf 0 Byte setzen
  TX_FULL = false;
  
  sei();
}

//------------------------------------------
//Bestimmte Zeit in ms warten; Achtung: Immer nur 10ms Schritte möglich
//Benutzt Timer2
//------------------------------------------

void wait(unsigned int ms)
{
  unsigned int cycles_10ms;
  ms = ms / 10;        //ms durch 10 teilen, so oft muss der Timer aufgerufen werden
  cycles_10ms = F_CPU / 1024 / 100;  //Berechnet die Taktzyklen, die für 10ms gewartet werden müssen
            //Bei 14,7456 MHz und einem Prescaler von 1024 muss man 144 Zyklen warten für 10ms
                    
  pt_1 = &ms;        //Globalen Pointer auf die ms Variable erstellen
  //Timer initialisieren
  
  OCR2 = cycles_10ms;      //Zyklen, die gewartet werden müssen ins Compare Register schreiben
  TIMSK |= 0b10000000;      //Interrupt für Timer2 setzen (bei Compare Match)
  TCCR2 = 0b00001111;      //Timer an mit Prescaler 1024, Clear Timer on Compare Match 1
  
  while(*pt_1 > 0);      //Warten bis Zeit abgelaufen
            //Achtung: TX und RX lösen immernoch Interrupts aus
                  
  TCCR2 = 0b00000000;      //Timer stoppen
}
//------------------------------------------
//Sendet Daten via USART
//Rückgabewerte bedeuten folgendes:
//0: OK
//1: Sendepuffer zu klein für Daten, die gesendet werden sollen
//------------------------------------------
int TX(char data[TX_BUFFER_SIZE])
{
  unsigned int i;
  unsigned int data_len;
  //TX_Buffer_In: Position an die geschrieben werden kann
  //TX_Buffer_Out: Position von der als nächstes gelesen und verschickt wird
  
  data_len = strlen(data);
  if(data_len>TX_free_size())
  {
    return 1;
  }  
  
  //Schreibe Daten in den TX Puffer
  for(i=0; i < data_len; i++) 
  {
    TX_Buffer[TX_Buffer_In] = data[i];    //Schreibe Byte in TX Buffer
    if(TX_Buffer_In == (TX_BUFFER_SIZE-1))
    {
      TX_Buffer_In = 0;      //Wenn am Ende des Speichers angekommen, gehe zum Anfang des Speichers
    }
    else
    {
      TX_Buffer_In++;        //Gehe zur nächsten Puffersektion
    }
    
  }
  if(TX_Buffer_In == TX_Buffer_Out)
  {
    TX_FULL = true;          //Schreib-Adresse erreicht Lese-Adresse
  }
  
  
  
  UCSRB |= (1<<UDRIE);          //UDRE Interrupt aktivieren. Na dann mal senden :)
  
  return 0;            //Gebe 0 zurück --> Alles in Ordnung
}
//------------------------------------------
//Gibt freie Anzahl an Byte zurück im TX Puffer
//------------------------------------------
int TX_free_size(void)
{
  if(TX_Buffer_In > TX_Buffer_Out)
  {
    return (TX_BUFFER_SIZE-(TX_Buffer_In - TX_Buffer_Out));
  }
  else
  {
    if(TX_Buffer_In < TX_Buffer_Out)
    {
      return (TX_BUFFER_SIZE - TX_Buffer_Out + TX_Buffer_In);
    }
    else
    {
      if(TX_FULL)
      {
        return 0;
      }
      else
      {
        return TX_BUFFER_SIZE;
      }
    }
  }
}
//------------------------------------------
//Interrupts
//------------------------------------------
//------------------------------------------
//USART Data Register Empty 
//------------------------------------------
ISR(USART_UDRE_vect)
{
  UDR = TX_Buffer[TX_Buffer_Out];      //Sende aktuelles Byte
  
  if(TX_Buffer_Out == (TX_BUFFER_SIZE-1))    //Wenn die alte Position, die letzte Position im Array ist
  {
    TX_Buffer_Out = 0;      //Neue Position ist erste Position im Array
  }
  else
  {
    TX_Buffer_Out++;      //Sonst: Nächste Position im Puffer
  }
  TX_FULL = false;


  if(TX_free_size() == TX_BUFFER_SIZE)    //Keine Daten mehr zum Senden
  {
    UCSRB = ~(UCSRB & (1<<UDRIE));    //UDRE Interrupt deaktivieren
  }
  return;
}
//------------------------------------------
//Timer/Counter2 Compare Match 
//------------------------------------------
ISR(TIMER2_COMP_vect )
{
  *pt_1 = *pt_1 - 1;    //Speicherinhalt um 1 dekrementieren (Pointer 1, sollte auf ms Variable zeigen)
  return;
}

[Stefan E. (sternst)]

    UCSRB = ~(UCSRB & (1<<UDRIE));    //UDRE Interrupt deaktivieren

Das deaktiviert zwar tatsächlich den UDRE-Interrupt, aktiviert dafür 
aber die beiden anderen Interrupts und setzt überhaupt alle anderen Bits 
in dem Register auf 1.

[Matthias L. (Gast)]

Du solltest das als kompetten Ringpuffer mit dynamischer Länge aufbauen. 
Etwa so:

//** globale Variablen ************************************************
volatile  struct
{
  //-- Tx-Ablauf -------------------------------------
  uint8_t               u8TxState;
  uint8_t               u8TxStateLast;
  //-- Sende-FIFO ---------------------------------
  uint8_t         au8TxData [1024];     // Datenpuffer
  uint16_t       au16TxRef [  16];       // Ref-Tabelle
  uint8_t         au8TxLen  [  16];        // Länge
  uint8_t         u8TxInp;                      // INP-Referenz
  uint8_t         u8TxOut;                      // OUT-Referenz
  uint8_t         u8TxSend;                  // Sendezähler;
  uint8_t         u8Msg;                       // Anzahl der Nachrichten im FIFO
  uint16_t              u16Fill;                // Anzahl der Bytes im FIFO
}
scRs232;


void     os_rs232_send_direct( uint8_t* pau8Data, uint8_t u8Len )
{
  //-- lokale Variablen ------------------------------------------------
  uint16_t    u16Buff   = (uint16_t) sizeof(scRs232.au8TxData);
  uint16_t    u16Array  = ( u16Buff - scRs232.u16Fill );
  uint8_t     u8Max     = (uint8_t)  sizeof(scRs232.au8TxLen );
  uint8_t     u8Idx     = 0;
  //-- Eingangsvariablen prüfen -------------------------------------
  if ( pau8Data == 0 ) return;
  if ( u8Len    == 0 ) return;
  //-- genügend Platz im FIFO? -------------------------------------
  if ( (uint16_t)u8Len >  u16Array ) return;
  if ( scRs232.u8Msg   == u8Max    ) return;
  //-- ins FIFO eintragen -----------------------------------------------
  u16Array = scRs232.au16TxRef[ scRs232.u8TxInp ];
  u8Idx    = 0;
  while ( u8Idx != u8Len )
  {
    scRs232.au8TxData[u16Array] = *pau8Data;
    /*-- weiter ---------------------------------*/
    pau8Data++;
    u8Idx++;
    u16Array++;
    if ( u16Array == u16Buff ) u16Array = 0;
  }
  //-- Referenz aktualisieren --------------------------------------------------
  scRs232.u16Fill  += (uint16_t)u8Len;
  scRs232.au8TxLen[scRs232.u8TxInp] = u8Len;
  if ( ++scRs232.u8TxInp == u8Max )  scRs232.u8TxInp = 0;
  scRs232.au16TxRef[ scRs232.u8TxInp ] = u16Array;
  scRs232.u8Msg++;
}



ISR    ( USART1_UDRE_vect )
{
  //-- lokale Variablen ------------------------------------------------------------
  uint16_t    u16Buff   = (uint16_t) sizeof(scRs232.au8TxData);
  uint16_t    u16Idx    = scRs232.au16TxRef[scRs232.u8TxOut];
  uint8_t     u8Len     = scRs232.au8TxLen [scRs232.u8TxOut];
  uint8_t     u8Max     = (uint8_t)  sizeof(scRs232.au8TxLen );
  //-- Datum senden --------------------------------------------------------------
  UDR1 = scRs232.au8TxData[u16Idx];
  if ( ++u16Idx == u16Buff )
  {
    u16Idx = 0;
  }
  scRs232.au16TxRef[scRs232.u8TxOut] = u16Idx;
  //-- vollständig gesendet? ----------------------------------------------------
  if ( ++scRs232.u8TxSend != u8Len ) return;
   //-- Msg aus FIFO entfernen ------------------------------------------------
  scRs232.u16Fill  -= (uint16_t) u8Len;
  scRs232.u8Msg--;
  if ( ++scRs232.u8TxOut == u8Max   ) scRs232.u8TxOut = 0;
  //-- fertig, ISR abschalten -----------------------------------------------------
  UCSR1B   &=  ~(1<<UDRIE1);
}




void     os_rs232_run( void )
{
  switch ( scRs232.u8TxState )
  {
    //-- TX: Init Ablauf -------------------------------------------------------
  case cRS232_TxInit:
    //-- ENTRY -----------------------------------
    scRs232.u8TxStateLast = scRs232.u8TxState;
    //-- ACTION -----------------------------------
    //-- TRANSITION ----------------------------
    scRs232.u8TxState = cRS232_TxIdle;
    //-- EXIT ---------------------------------------
    break;

   //-- TX: warten auf Msg ------------------------------------------------
  case cRS232_TxIdle:
    //-- ENTRY ------------------------------------
    if ( scRs232.u8TxStateLast != scRs232.u8TxState )
    {
      scRs232.u8TxStateLast = scRs232.u8TxState;
    }
    //-- ACTION ------------------------------------
    //-- TRANSITION -----------------------------
    if ( scRs232.u8Msg != 0 )
    {
      scRs232.u8TxState = cRS232_TxSend;
    }
    //-- EXIT ----------------------------------------
    break;

   //-- TX: Senden -----------------------------------------------------------
  case cRS232_TxSend:
    //-- ENTRY ------------------------------------
    if ( scRs232.u8TxStateLast != scRs232.u8TxState )
    {
      scRs232.u8TxStateLast = scRs232.u8TxState;
      //-- Senden anstoßen -----
      scRs232.u8TxSend = 0;
      UCSR1B   |=  (1<<UDRIE1);
    }
    //-- ACTION ------------------------------------
    //-- TRANSITION -----------------------------
    if (  !( UCSR1B & (1<<UDRIE1) )  )
    {
      scRs232.u16CntTxD++;

      if (  UCSR1A & (1<<TXC1) )
      {  
        scRs232.u8TxState = cRS232_TxIdle;
        if ( scRs232.u8Msg != 0 )
        {
          scRs232.u8TxState = cRS232_TxWait;
        }
      }
    }
    //-- EXIT -----------------------------------------
    break;

  //-- TX: Pause generieren ---------------------------------------------
  case cRS232_TxWait:
    //-- ENTRY --------------------------------------
    if ( scRs232.u8TxStateLast != scRs232.u8TxState )
    {
      scRs232.u8TxStateLast = scRs232.u8TxState;
      //-- Verzögerung setzen ----
      OCR3A =  ( TCNT3 + scRs232.u16Delay );
      TIFR3 |= (1<<OCF3A);
    }
    //-- ACTION ---------------------------------------
    //-- TRANSITION --------------------------------
    if ( TIFR3 & (1<<OCF3A) )
    {
      scRs232.u8TxState = cRS232_TxSend;
    }
    //-- EXIT -------------------------------------------
    break;

  //-- TX: ungültig ----------------------------------------------------------
  default:
    scRs232.u8TxState = cRS232_TxInit;
  }

Das hab ich so für meine Propelleruhr programmiert. Der Vorteil ist, 
dass die Länge der zu sendenden Nachrichten variieren kann. Dort, wo man 
Senden will, nur das os_rs232_send_direct aufrufen und fertig. Das 
os_rs232_run muss zyklisch aufgerufen werden und managt im Hintergrund 
das Senden der Nachrichten im FIFO. Zwischen den Nachrichten wird 
automatisch eine Pause von ca. 2..4 Bytelängen eingefügt.

PS: Ich hab die c und h Datei für Interessenten mal angehängt. WIe 
besonders am RX_Teil zu erkennen ist, bin ich da noch dran.

Das Ganze arbeitet in einem speziellen Kontest, deshalb mögen einige 
Details kurios erscheinen.
http://www.avrs-at-leipzig.de/dokuwiki/projekte/propelleruhr

;-)

[Matthias L. (Gast)]

Hier die Dateien. Das hat erst nachträglich nicht geklappt.

PS: Wieso muss ich denn hier einen längeren Text eingeben?

[Michael E. (micde)]

Stefan Ernst schrieb:
> Das deaktiviert zwar tatsächlich den UDRE-Interrupt, aktiviert dafür
> aber die beiden anderen Interrupts und setzt überhaupt alle anderen Bits
> in dem Register auf 1.

Du hast Recht! Das habe ich gerade auch nochmal durchgespielt.

das sollte wohl eher so aussehen:

UCSRB = (UCSRB & ~(1<<UDRIE));

Vielen Dank für den Hinweis!

Vielen Dank auch an Dich Matthias. Ich schau mir Deinen Code gleich mal 
an.

Macht irgendwo auch Sinn den Puffer dynamisch aufzubauen. Dann kann der 
Speicherbereich genutzt werden wenn gerade nichts zum Senden ansteht! :)

Viele Grüße

Michi


Nachtrag:

Das war das Problem Stefan :) Ich glaub' ich spiel nächstes Mal die 
Bitoperationen nicht mehr im Kopf, sondern auf nem Blatt Papier durch!
Nochmals vielen Dank!

Das Problem an der Sache war (neben dem versehentlichen Setzen von 
sämtlichen USART Interrupts außer dem USART Data Register Empty 
Interrupt), dass auch das UCSZ2 Bit gesetzt wurde von 011 (8 Bit Data 
Mode) auf 111 (9 Bit Data Mode).