AVR ATMega324PA USART Daten empfangen via Interrupt

[Julian B. (zitrone18)]

Hallo zusammen,

wie der Betreff schon sagt, habe ich einen ATMega324PA und möchte beide 
USART's mit Interrupts verwenden. Ich habe das Ganze mal in einem 
minimalen Programm komprimiert, erstmal nur für eine Schnittstelle.
Die Sende-/ und Empfangsdaten sollen in einem Ringspeicher abgelegt 
werden. Wichtiger sind mir die Empfangsdaten an dieser Stelle. Die 
Senderoutine kann ich zur Not auch ohne ISR basteln.

Im Anhang findet ihr meinen aktuellen Code.
In der Main prüfe ich, ob sich der Schreib-/ und Lesepointer 
unterscheiden und möchte daraufhin ein Byte aus dem Speicher laden und 
an den PC zurückschicken.

Das Delay am Ende ist aktuell auskommentiert. So funktioniert es nicht!
Wenn ich das Delay einkommentieren dann funktioniert die Kommunikation.
Kleiner als 2ms darf ich den Delay aber auch nicht machen und bei vielen 
Daten überholt der Schreib-/ den Lesepointer.
Warum braucht der Knecht diese Auszeit?
Er Antwortet mir ohne den Delay nichtmal auf einzelne Bytes...


Der Prozessor läuft mit einem 14,7456 Mhz Quarz bei 115200 Baud.
Die Fuse-Bits stehen auf High = 0xD9 und Low = 0xFF.

Ich hoffe ich habe alle wichtigen Infos gegeben.

Gruß,
Zitrone

[jojo (Gast)]

Hi, ich habe auf nem Atmega16 mal ne kommunikation mit Sendefifo und 
Interrupt gabastelt, und habe aber nicht den UDRE (Uart Data register 
empty)interrupt benutzt, sondern den TXC (transmition complete).

Ich glaube mich zu erinnern, dass ich ähnliche Probleme hatte, wenn der
Tx-Interrupt kam, bevor die Daten komplett gesendet wurden.

Versuchs doch mal damit.

vg. Norbert

[jojo (Gast)]

Nachtrag:

Für Tx-complete musst Du allerdings immer das Erste Byte manuell senden, 
wenn der Sendebuffer zuvor leer war.

Die folgenden folgende Queue kann dann vom Interrupt geleert werden.

static uint8   UartTxActiv;

void UartInit(UartBdr_t bdr)
{
#if (UART_PRINT_BY_QUEUE)
   /* initialise TX Queue*/
   FifoInit(&UartTxFifo, UartTxBuffer, sizeof(UartTxBuffer));
#endif

   uint16 baud = __LPM_word(&UartBdrTab[bdr]);       /* read BdrTab from Progmem */

   UBRRH = (uint8)(baud >>8);
   UBRRL = (uint8)(baud);

   UCSRA  = (1<<U2X);                                /* Baudrate divisor =8 */

   UCSRB  = (1<<RXEN) | (1<<TXEN);                   /* Enable RX und TX */

#if (UART_PRINT_BY_QUEUE)
   UCSRB  |= (1<<TXCIE);                             /* Enable Tx Interrupt*/
#endif

   /*       async      par even   StopBits 2  Databits 8 */
   UCSRC = (1<<URSEL)| (0<<UPM0)| (0<<USBS) | (3<<UCSZ0);
}
/*******************************************************************************
**                                                                            **
** FUNC-NAME     : UartTx                                                     **
**                                                                            **
** DESCRIPTION   Routine writes a byte to the Uart TxFifo buffer              **
**               If no transmittion is activ, it copies the byte from the     **
**               buffer to the TxRegister and starts the transmition.         **
**               If the buffer is full, it waits until there is some          **
**               space left.                                                  **
**                                                                            **
** PARAMETER     : uint8 data_b:    byte to transmit                          **
**                                                                            **
** RETURN        : -                                                          **
**                                                                            **
*******************************************************************************/
void UartTx(uint8 data_b)
{
#if (UART_PRINT_BY_QUEUE)
   // Hier wird bei vollem Fifo bis zum Erfolg versucht zu schreiben
   while(!FifoWriteByte(&UartTxFifo, data_b));
   /* Wenn aktuell keine Uebertragung mehr aktiv ist, dann muss das erste Byte
      von Hand uaf das UDR Register geschrieben werden*/
   if(UartTxActiv ==0)
   {
      if( FifoReadByte(&UartTxFifo,&data_b) )
      {
         UDR = data_b;
         UartTxActiv =1;
      }
   }
#else
   while( !(UCSRA & (1<<UDRE)) );
   UDR = data_b;
#endif
}


/*******************************************************************************
**                                                                            **
** FUNC-NAME     : Interrupt 'USART_TXC_vect'                                 **
**                                                                            **
** DESCRIPTION   : Uart Transmition Complete Service Routine:                 **
**                 Routine occures each time a Uart Transmition has completed **
**                 It copies the next byte to transmit from TxFifo buffer to  **
**                 the uart transmit register - until Fifo is empty.          **
**                                                                            **
** PARAMETER     : -                                                          **
**                                                                            **
** RETURN        : -                                                          **
**                                                                            **
*******************************************************************************/
ISR(USART_TXC_vect)
{
#if (UART_PRINT_BY_QUEUE)
   uint8 data;
   // Byte aus dem Fifo lesen
   if( FifoReadByte(&UartTxFifo,&data) )
   {
      // Daten vorhanden ->Byte Uart Data Register schreiben
      UDR = data;
   }
   else
   {
      // Keine Daten mehr vorhanden-> Uebertragung auf inaktiv setzen
      UartTxActiv = 0;
   }
#endif
}

[Karl H. (kbuchegg)]

Und wieder mal: VOLATILE !

FAQ: Was hat es mit volatile auf sich

  while(1)
  {
    if(!(ptrRecWrite == ptrRecRead))
    {
      input = uart0_getc();
      uart0_putc(input);
    }
    //_delay_ms(2);          //Wenn drin gehts. Wenn nicht dann nicht!
  }

ist der _delay nicht drinnen, hat der Compiler genug Register frei um 
sich die Werte für ptrRecWrite bzw. ptrRecRead in CPU-Registern halten 
zu können. Da passiert einfach zu wenig in der Hauptschleife, als das er 
die Werte jedesmal aus dem Speicher nachladen müsste.

[Karl H. (kbuchegg)]

Julian B. schrieb:

> Kleiner als 2ms darf ich den Delay aber auch nicht machen und bei vielen
> Daten überholt der Schreib-/ den Lesepointer.

Könnte ein Hinweis auf einen weiteren Fehler sein, auch wenn ich beim 
Drüberscrollen nichts mehr gesehen habe.
Aber ergänze mal das fehlende volatile an den Pointer Variablen. Und 
dann sieht man weiter.

[Julian B. (zitrone18)]

Hallo zusammen,

danke für die Antworten.

@ Norbert:
Das habe ich im Vorfeld auch schon ausprobiert. Habe es gerade aber 
nochmal gemacht. Allerdings ohne Erfolg die Daten (0xAA, 0xBB, 0xCC) 
werden korrekt ausgegeben aber Daten annehmen will der Knecht nicht. 
Schade.

@ Karl Heinz:
Entschuldige bitte, dass ich die Version ohne volatile hochgeladen habe. 
Volatile ist mir bekannt und benutze ich auch da wo es sinnvoll ist. Ich 
habe die Variablen jetzt wie folgt Deklariert:

 //VARS
#define TRANSBUF_SIZE  150
uint8_t transBuffer[TRANSBUF_SIZE];    // Sendebuffer
volatile uint8_t* ptrTransStart;          // Startadresse
volatile uint8_t* ptrTransEnd;          // Letzte Adresse + 1
volatile uint8_t* ptrTransWrite;          // aktuelle Schreibadresse
volatile uint8_t* ptrTransRead;          // aktuelle Leseadresse

#define RECBUF_SIZE  150
uint8_t recBuffer[RECBUF_SIZE];      // Empfangsbuffer
volatile uint8_t* ptrRecStart;      // Startadresse
volatile uint8_t* ptrRecEnd;        // Letzte Adresse + 1
volatile uint8_t* ptrRecWrite;          // aktuelle Schreibadresse
volatile uint8_t* ptrRecRead;          // aktuelle Leseadresse
uint16_t countData;

Leider auch ohne Erfolg. Das habe ich im Vorfeld auch schon mehrfach 
ausprobiert mal mit mal ohne usw..... volatile sollte an dieser Stelle 
natürlich verwendet werden.

Leider besteht das Problem mit den empfangenen Daten weiterhin. Ich 
verstehe nur leider nicht warum...

[Karl H. (kbuchegg)]

Julian B. schrieb:

> Leider auch ohne Erfolg.

Logisch. Ist ja auch falsch geschrieben

uint8_t* volatile ptrTransStart;
...

Der Pointer Wert selber ist volatile. Nicht das worauf er zeigt.
D.h. eigentlich ist das auch volatile. Also

volatile uint8_t* volatile ptrTransStart;
...

Diese Modifier wirken immer von rechts nach links. Es sei denn, der 
Modifier steht schon ganz links, dann wirkt er auf das Teil rechts von 
ihm

uint8_t* volatile ptr;

Das Volatile bezieht sich auf den Pointer, denn der * steht links von 
ihm

     ptr
    +------+           +---+
    |  o-------------->|   |
    +------+           +---+
       ^
       | das hier ist volatile

uint8_t volatile * ptr;

Das volatile bezieht sich auf den uint8_t, denn der steht links von ihm. 
Der Pointerwert selber ist nicht volatile, wohl aber das worauf er 
zeigt.

     ptr
    +------+           +---+
    |  o-------------->|   |
    +------+           +---+
                         ^
                         | das hier ist volatile

volatile uint8_t * ptr;

selber Fall. das volatile bezieht sich auf den uint8_t, weil das 
volatile schon ganz links steht.


Du vergleichst die Pointer Werte (und nicht das worauf die Pointer 
zeigen). Ergo müssen die Pointer Werte volatile sein. Mit

volatile uint8_t * ptr;

sind sie es aber nicht.


Und zu guter letzt

volatile uint8_t * volatile ptr;

     ptr
    +------+           +---+
    |  o-------------->|   |
    +------+           +---+
       ^                 ^
       |                 | das hier ist volatile
       |
       | und das hier ist auch volatile

[jojo (Gast)]

noch ne möglichkeit dem volatile zu entgehen (für teste obs daran 
liegt).

Ein nicht optimierter Code braucht in der Regel kein volatile d.h. wenn 
Du das Ding mit -O0 übersetzt und es läuft und be -O2 läufts nicht mehr, 
dann kanst Du davon ausgehen, irgendwo ein fehlendes volatile zu haben.

[Julian B. (zitrone18)]

Hier der aktuelle Stand:

Volatile hat in keiner Form was gebracht (Habe alle ausprobiert) Bei den 
Version

volatile uint8_t * volatile ptr;

 schickt der Prozessor mir permanent 0x00.....

Die Optimierung habe ich mal ausgeschaltet. Bringt aber auch nichts, 
außer dass die Anfangswerte 0xAA,0xBB und 0xCC nicht mehr ausgegeben 
werden...

Ich werde mir da noch einige Gedanken zu machen.

[Karl H. (kbuchegg)]

Julian B. schrieb:
> Hier der aktuelle Stand:
>
> Volatile hat in keiner Form was gebracht

Gut.
Nichts desto trotz gehört es da rein.

Sagt ja keiner, dass das das einzige Problem im Code ist.

[Svenska (Gast)]

Ich würde statt Pointern übrigens mit Indizes rechnen.
Dann laufen die beiden Pointer von 0..BUFSIZE-1, was bei Zweierpotenzen 
ziemlich einfach zu berechnen ist. Auf die Daten greifst du dann mit 
buf[read_idx] zu.

[Julian B. (zitrone18)]

Hey Svenska,

die Idee mit den Indizes hatte ich kurz vor Feierabend dann auch. Ist 
denke ich auch verständlicher als die Spielerei mit den Pointern...

Ich werde das morgen mal ausprobieren. Ich danke euch erstmal und werde 
berichten :)

Gruß

[Julian B. (zitrone18)]

Tag zusammen,

habe den Fehler gefunden... Er lag nicht an der Software.
Ich habe einen Kurzschluss auf meinem Board gehabt.
Zwischen RX und TX...

Den Fehler habe ich gefunden nachdem ich auf Indizes umgestiegen bin.
Im Anhang der Code mit Indizes...

Danke für eure Hilfe!

[Julian B. (zitrone18)]

Und hier noch die Version mit Pointern...(s. Anhang)