Uart Interrupt Problem

[Bastler07 (Gast)]

Hi
ich versuche momentan mit dem Rechner und meinem Atmega32 eine Uart 
Kommunikation aufzubauen. Nun kann ich Zeichen zum Terminalprogramm 
schicken, aber ich bekomm nichts empfangen, obwohl der Interrupt 
ausgelöst wird.
Kann mal jemand über den Code schauen. Achja, der Uart-Code kommt von 
Fleurys HP, den Interruptcode habe ich hier aus dem Tutorial und den 
uart_gets code nutze ich momentan nicht.

Vielen Dank

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "uart.h"
#include "lcd.h"

#ifndef F_CPU
#define F_CPU 16000000L
#endif


//#define ATMEGA_USART1
#define UART_BAUD_RATE 9600      
#define UART_MAXSTRLEN 10
 
volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";

void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
 
                                  // /Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';
}

ISR(SIG_USART_RECV)
{
  uart_str_complete=1;
  //uart_gets((char*)uart_string,10);

  unsigned char nextChar;
 
  //nextChar = UDR;
  nextChar = UDR0;
  if( uart_str_complete == 0 ) 
  {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
 
    // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
        nextChar != '\r' &&
        uart_str_count < UART_MAXSTRLEN - 1 ) 
  {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

int main()
{
  char Line[40];      

  Init_LCD();
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 
  Clear_LCD();

  sei();


    GotoXY_LCD(0,0);
    LCD_PutString_P(PSTR("UART \r\n\n"));
  Update_LCD();

  uart_puts("T\n");
  
  while(1)
  {
    //uart_puts("T\n");
    if(uart_str_complete==1)
    {
      //uart_gets(Line, sizeof( Line ) );
      //uart_puts(Line);
      Clear_LCD();
      GotoXY_LCD(0,0);
        LCD_PutString((const char*)uart_string);
      uart_puts((const char*)uart_string);
      LCD_PutString_P(PSTR("\r\n"));
      LCD_PutString_P(PSTR("Erfolg  \r\n\n"));

      uart_puts((const char*)uart_string); 
      uart_str_complete=0;
    }
    
    Update_LCD();
    //_delay_ms(1000);
  }

   return 0;

[Bastler07 (Gast)]

Nochmal genauer:
Wenn ich Zeichen vom Terminal bekomme, wird der Interrupt ausgelöst, 
aber der empfangene String wird nicht zurückgesendet und auch nicht auf 
dem LCD gezeigt. Es entsteht nur eine leere Zeile

[... (Gast)]

Das ist schon mal Mist, SIG_USART_RECV ist schon ewig deprecated ind 
passt auch nicht zu "ISR":

ISR(SIG_USART_RECV)

und gleich danach

  uart_str_complete=1;

ist genauso Mist

[Bastler07 (Gast)]

das uart_str_complete=1; habe ich oben nur eingefügt, um zu wissen, ob 
der interrupt funktioniert

was ist mit ISR(SIG_USART_RECV) los? der interrupt geht doch...

[... (Gast)]

Bastler07 schrieb:
> was ist mit ISR(SIG_USART_RECV) los? der interrupt geht doch...

Ja aber nur bei wenigen alten AVRs. Bei den neueren gibt es die alten 
Namen schon nicht mehr. Korrekter wäre:

ISR(USART_RXC_vect)

Die alten "SIG_*" Namen stammen aus einer Zeit, als es noch kein "ISR" 
Makro gab und man statt dessen "INTERRUPT" und "SIGNAL" benutzt hat und 
jeder Neuling damit erstmal fürchterlich auf die Nase gefallen ist, weil 
er beide verwechselt hat.

[... (Gast)]

... ach so, und das

uart_str_complete=1;

in der ISR ist trotzdem Mist. Es sorgt dafür, das in uart_string 
generell nur ein Leerstring steht.

[Bastler07 (Gast)]

okay, danke
das hilft mri schonmal weiter

habe gerade mal ISR(USART_RXC_vect) eingefügt, nun fällt mir ein, dass 
hatte ich vorher drin, aber ich bekomme immer die Meldung

../MultiPong.c:51: warning: 'UART_RXC_vect' appears to be a misspelled 
signal handler


klar, mit dem uart_str_complete=1; wird die if anweisung ja umgangen
vollkommen übersehen

kannst du mir auch noch den Fehler für das nicht empfangen des strings 
nennen?

danke nochmal

[Karl H. (kbuchegg)]

Bastler07 schrieb:
> okay, danke
> das hilft mri schonmal weiter
>
> habe gerade mal ISR(USART_RXC_vect) eingefügt, nun fällt mir ein, dass
> hatte ich vorher drin, aber ich bekomme immer die Meldung
>
> ../MultiPong.c:51: warning: 'UART_RXC_vect' appears to be a misspelled
> signal handler

Der heisst auch
    USART_RXC_vect
und nicht
    UART_RXC_vect


Wenn du dir nicht sicher bist, wie der Interrupt auf deinem µC heisst, 
dann sieh in der iom32.h nach. AVR Studio müsste diese Datei unter 
"External Dependencies" führen. Dort finden sich neben vielen anderen 
Sachen, auch die Namen der INterrupt Vektoren.

Eines würde mich noch interessieren.
Wie hast du das

    nextChar = UDR0;

durch den Compiler gekriegt? Der Mega32 hat nur eine UART und bei dem 
heisst das USART Data Register UDR und nicht UDR0.

> klar, mit dem uart_str_complete=1; wird die if anweisung ja umgangen
> vollkommen übersehen
>
> kannst du mir auch noch den Fehler für das nicht empfangen des strings
> nennen?

Das

 uart_str_complete=1;

IST der Fehler der dafür verantwortlich ist. Deine Empfangsroutine 
meldet viel zu früh, dass die Zeile komplett empfangen wurde. Nämlich zu 
einem Zeitpunkt, an dem noch gar kein String zusammengebaut wurde.

[Bastler07 (Gast)]

Karl Heinz Buchegger schrieb:
> Der heisst auch
>     USART_RXC_vect
> und nicht
>     UART_RXC_vect

ich habe beides probiert, die Warnung bleibt
../MultiPong.c:51: warning: 'UART_RXC_vect' appears to be a misspelled
 signal handler


und nach dem löschen von uart_str_complete=1; gehts trotzdem noch nicht

so hatte ich es ja auch in meiner ersten Version, da dachte ich dann, er 
kommt nicht zum interrupt und habe es daher nochmal davor eingefügt

irgendwie ist da noch was falsch

[Karl H. (kbuchegg)]

Bastler07 schrieb:
> Karl Heinz Buchegger schrieb:
>> Der heisst auch
>>     USART_RXC_vect
>> und nicht
>>     UART_RXC_vect
>
> ich habe beides probiert, die Warnung bleibt
> ../MultiPong.c:51: warning: 'UART_RXC_vect' appears to be a misspelled
>  signal handler

Wenn in der Fehlermeldung steht, dass UART_RXC_vect ein nicht bekannter 
Interrupt Vektor ist, dann kannst du nicht USART_RXC_vect (mit einem S 
nach U und vor A) geschrieben haben, denn dann würde die Fehlermeldung 
sagen, dass USART_RXC_vect ein unbekannter signal handler ist. Tut es 
aber nicht. Die Fehlermeldung spricht von UART_RXC_vect, ohne das S 
zwischen U und A.

Aber da du offenbar UDR0 durch den Compiler kriegst, gehe ich mal davon 
aus, dass du entweder deinen Compiler oder uns angelogen hast und 
entweder hast du im AVR-STudio keinen Mega32 eingestellt oder du hast 
keinen Mega32. Auf jeden Fall stimmt da aber was nicht.

Alle UART Register und sonstige Dinge, die mit UART zu tun haben, haben 
nur dann eine Zahl dahinter (wie bei UDR0), wenn es mehr als 1 UART 
gibt. Das ist immer so und gilt auch für alles. Wenn du also 2 USART im 
µC hast, dann hast du ein UDR0 und ein UDR1. Du hast dann aber auch 
logischerweise ein USART_RXC0_vect und einen USART_RXC1_vect.

Ein Mega32 hat aber keine 2 UART, sondern nur eine.
Daher heisst das Empfangsregister dort UDR und der Interrupt Vektor 
heißt USART_RXC_vect.


> und nach dem löschen von uart_str_complete=1; gehts trotzdem noch nicht

Dann zeig dein Programm wie es jetzt aussieht.
Aber in compilierbarer Form (keine Fehlermeldungen oder Warnungen mehr)!

[Bastler07 (Gast)]

oh, da gibt es wohl ein missverständnis
ich habe den Atmega324p und dachte das ist ein Atmega32
jedenfalls habe ich bei meinem 324p 2 USARTs und möchte USART0 verwenden

 
#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "uart.h"
#include "lcd.h"

#ifndef F_CPU
#define F_CPU 16000000L
#endif


//#define ATMEGA_USART1
#define UART_BAUD_RATE 9600      
#define UART_MAXSTRLEN 10
 
volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";

void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
 
                                  // /Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';
}

//ISR(USART0_RXC)
ISR(USART_RXC0_vect)
{
  unsigned char nextChar;
 
  //nextChar = UDR;
  nextChar = UDR0;
  if( uart_str_complete == 0 ) 
  {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
 
    // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
        nextChar != '\r' &&
        uart_str_count < UART_MAXSTRLEN - 1 ) 
  {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

int main()
{
  char Line[40];      

  Init_LCD();
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 
  Clear_LCD();

  sei();


    GotoXY_LCD(0,0);
    LCD_PutString_P(PSTR("UART \r\n\n"));
  Update_LCD();

  uart_puts("T\n");
  
  while(1)
  {
    //uart_puts("T\n");
    if(uart_str_complete==1)
    {
      //uart_gets(Line, sizeof( Line ) );
      //uart_puts(Line);
      Clear_LCD();
      GotoXY_LCD(0,0);
        LCD_PutString((const char*)uart_string);
      uart_puts((const char*)uart_string);
      LCD_PutString_P(PSTR("\r\n"));
      LCD_PutString_P(PSTR("Erfolg  \r\n\n"));

      uart_puts((const char*)uart_string); 
      uart_str_complete=0;
    }
    
    Update_LCD();
    //_delay_ms(1000);
  }

   return 0;

Warning:
warning: 'USART_RXC0_vect' appears to be a misspelled signal handler

Danke

[Karl H. (kbuchegg)]

Bastler07 schrieb:
> oh, da gibt es wohl ein missverständnis
> ich habe den Atmega324p und dachte das ist ein Atmega32

Was eine falsche Zahl alles ausmachen kann :-)

> Warning:
> warning: 'USART_RXC0_vect' appears to be a misspelled signal handler

Ok.
In deinem Projekt Baum im AVR Studio sind alle Files aufgeführt. Da gibt 
es unter "External Dependencies" eine iom324.h
Wenn man da reinschaut sieht man, dass da die Definitionen nicht drinnen 
sind. Aber es gibt noch eine zweite iom Datei: die IOMXX4.H
Und wenn man in der nach USART sucht, dann findet sich der Interrupt 
Vektor

USART0_RX_vect

zusammen mit dem Kommentar

/* USART0, Rx Complete */

Bingo. Der ist es.

So sucht man Namen, die man nicht kennt, wenn man nicht sowieso im 
Datenblatt nachsieht. Alle prozessorspezifischen Dinge sind immer in 
einem Header File, das den Namen IOM und einen prozessorspezifischen 
Postfix trägt. Dort kann man nachsehen und mit den richtigen 
Suchbegriffen wird man meistens auch recht schnell fündig.

[Bastler07 (Gast)]

Super, danke
die Warnung ist nun weg, allerdings kommen die Zeichen noch nicht an

liegt das vielleicht an einem falschen Cast?

[Helfer (Gast)]

Bastler07 schrieb:

> liegt das vielleicht an einem falschen Cast?

Oder an einer falsch übersetzten Library?
Haste die Fleury Lib für den m324 compiliert?

[Frank M. (ukw) (Moderator)]

Bastler07 schrieb:

> die Warnung ist nun weg, allerdings kommen die Zeichen noch nicht an

Erstmal ein paar Bemerkungen zu Deinem Source:

volatile uint8_t uart_str_count = 0;

Diese Variable benutzt Du nur in der ISR, Du kannst sie also in der ISR 
lokal definieren, nämlich als:

static uint8_t uart_str_count;

Die Funktion uart_gets() kann komplett weg, sie wird nicht benutzt und 
verwirrt hier nur.

Woher weisst Du, dass die ISR überhaupt aufgerufen wird? Ich sehe 
nämlich nirgendwo die Freigabe für USART0_RX_vect.

Gruß,

Frank

[Bastler07 (Gast)]

Helfer schrieb:

> Oder an einer falsch übersetzten Library?
> Haste die Fleury Lib für den m324 compiliert?

Wie ist das gemeint? Habe da nichts kompiliert, habe einfach die header 
und die c datei eingebunden

Frank M. schrieb

> Woher weisst Du, dass die ISR überhaupt aufgerufen wird? Ich sehe
> nämlich nirgendwo die Freigabe für USART0_RX_vect.

Die Freigabe passiert doch über

if(uart_str_complete==1)

 in meiner main funktion. Diese wurde vorher mal passiert, da ich Erfolg 
auf meinem Display bekam.

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "uart.h"
#include "lcd.h"

#ifndef F_CPU
#define F_CPU 16000000L
#endif


//#define ATMEGA_USART1
#define UART_BAUD_RATE 9600      
#define UART_MAXSTRLEN 10
 
volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile char uart_string[UART_MAXSTRLEN + 1] = "";

//ISR(USART0_RXC)
ISR(USART_RXC0_vect)
{
  unsigned char nextChar;
  static uint8_t uart_str_count;

 
  //nextChar = UDR;
  nextChar = UDR0;
  if( uart_str_complete == 0 ) 
  {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
 
    // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
        nextChar != '\r' &&
        uart_str_count < UART_MAXSTRLEN - 1 ) 
  {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

int main()
{
  char Line[40];      

  Init_LCD();
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 
  Clear_LCD();

  sei();


    GotoXY_LCD(0,0);
    LCD_PutString_P(PSTR("UART \r\n\n"));
  Update_LCD();

  uart_puts("T\n");
  
  while(1)
  {
    //uart_puts("T\n");
    if(uart_str_complete==1)
    {
      //uart_gets(Line, sizeof( Line ) );
      //uart_puts(Line);
      Clear_LCD();
      GotoXY_LCD(0,0);
        LCD_PutString((const char*)uart_string);
      uart_puts((const char*)uart_string);
      LCD_PutString_P(PSTR("\r\n"));
      LCD_PutString_P(PSTR("Erfolg  \r\n\n"));

      uart_puts((const char*)uart_string); 
      uart_str_complete=0;
    }
    
    Update_LCD();
    //_delay_ms(1000);
  }

   return 0;

[Frank M. (ukw) (Moderator)]

Bastler07 schrieb:
> Die Freigabe passiert doch über

if(uart_str_complete==1)

 in
> meiner main funktion.

Du hast mich falsch verstanden: Es reicht nicht, global die Interrupts 
über sei() freizuschalten, Du musst auch noch Deine ISR gezielt 
"enablen", siehe

  http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART#Empfangen_.28RX.29

(RXCIE spielt hier die Rolle)

Oder macht das bei Dir das uart_init()? Ich kann mir nicht vorstellen, 
dass die LIB, die Du benutzt, standardmäßig auf Interrupt-Betrieb 
ausgerichtet ist.

[Bastler07 (Gast)]

gute idee, aber das wird eigentlich über die uart_init() erledigt. Mein 
Compiler definiert doch den Atmega, so werden die defines freigeschaltet 
und somit die if-Bedinung in der Funktion uart_init() ausgeführt.

Oder muss ich nochmal extra meinen Atmega definieren?

aus Fleury`s uart lib:

#elif defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__)
 /* ATmega with two USART */
 #define ATMEGA_USART0
 #define ATMEGA_USART1
 #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
 #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
 #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
 #define UART0_STATUS   UCSR0A
 #define UART0_CONTROL  UCSR0B
 #define UART0_DATA     UDR0
 #define UART0_UDRIE    UDRIE0
 #define UART1_STATUS   UCSR1A
 #define UART1_CONTROL  UCSR1B
 #define UART1_DATA     UDR1
 #define UART1_UDRIE    UDRIE1


void uart_init(unsigned int baudrate)
{
    UART_TxHead = 0;
    UART_TxTail = 0;
    UART_RxHead = 0;
    UART_RxTail = 0;
    
#if defined( AT90_UART )
    /* set baud rate */
    UBRR = (unsigned char)baudrate; 

    /* enable UART receiver and transmmitter and receive complete interrupt */
    UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|_BV(TXEN);

#elif defined (ATMEGA_USART)
    /* Set baud rate */
    if ( baudrate & 0x8000 )
    {
       UART0_STATUS = (1<<U2X);  //Enable 2x speed 
       baudrate &= ~0x8000;
    }
    UBRRH = (unsigned char)(baudrate>>8);
    UBRRL = (unsigned char) baudrate;
   
    /* Enable USART receiver and transmitter and receive complete interrupt */
    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
    
    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
    #ifdef URSEL
    UCSRC = (1<<URSEL)|(3<<UCSZ0);
    #else
    UCSRC = (3<<UCSZ0);
    #endif 
    
#elif defined (ATMEGA_USART0 )
    /* Set baud rate */
    if ( baudrate & 0x8000 ) 
    {
       UART0_STATUS = (1<<U2X0);  //Enable 2x speed 
       baudrate &= ~0x8000;
     }
    UBRR0H = (unsigned char)(baudrate>>8);
    UBRR0L = (unsigned char) baudrate;

    /* Enable USART receiver and transmitter and receive complete interrupt */
    UART0_CONTROL = _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
    
    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
    #ifdef URSEL0
    UCSR0C = (1<<URSEL0)|(3<<UCSZ00);
    #else
    UCSR0C = (3<<UCSZ00);
    #endif 

#elif defined ( ATMEGA_UART )
    /* set baud rate */
    if ( baudrate & 0x8000 ) 
    {
      UART0_STATUS = (1<<U2X);  //Enable 2x speed 
      baudrate &= ~0x8000;
    }
    UBRRHI = (unsigned char)(baudrate>>8);
    UBRR   = (unsigned char) baudrate;

    /* Enable UART receiver and transmitter and receive complete interrupt */
    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);

#endif

}/* uart_init */

[Stefan E. (sternst)]

Und was hast du mit der Receive-Interrupt-ISR vom Fleury-Code gemacht? 
Gelöscht, auskommentiert, oder was? Dass es nicht 2 ISRs zum gleichen 
Interrupt geben kann, ist dir doch klar, oder?

[Bastler07 (Gast)]

Klar, den Fleury Interrupt habe ich gelöscht

[Frank M. (ukw) (Moderator)]

Bastler07 schrieb:
> gute idee, aber das wird eigentlich über die uart_init() erledigt.

Hast Du das _BV(RXCIE) dort reingebastelt oder war das schon drin? Wenn 
letzterers, muss es doch dort auch schon eine ISR dafür geben? Wenn ja, 
welche wird dann benutzt? die aus der Lib oder Deine eigene?

Eigentlich ist das Unsinn, dass Du eine LIB benutzt, die Du dann 
"hintenrum" durchlöcherst wie ein Schweizer Käse (wie z.B. durch eigene 
ISR bzw. durch eigenes uart_gets()).

[Bastler07 (Gast)]

Stimmt, ihr habt recht. Eigentlich wollte ich mir so eben was aufbauen, 
aber damit habe ich mir wohl mehr Probleme gemacht als alles andere.

Ich bin gegen abend wieder zuhause und werde es dann mal vernünftig und 
komplett neu aufbauen.

Ich melde mich dann heute abend wieder.

Danke für die Hilfe

[Bastler07 (Gast)]

der aufgräumte code, allerdings bleit das problem gleich
der atmega kann zum terminal senden, aber nicht empfangen

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "defines.h"
#include "twi.h"
#include "dataflash.h"

#ifndef F_CPU
#define F_CPU 16000000L
#endif

#define UART_MAXSTRLEN 10
 
volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";


void uart_init(void)
{
  UBRR0 = 103;
  UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);  // UART RX, TX und RX Interrupt einschalten
  UCSR0C = (1<<USBS0)|(3<<UCSZ00);        // Asynchron 8N1 

}

int uart_putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR0 = c;                      /* sende Zeichen */
    return 0;
}
 
 
/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
        uart_putc(*s);
        s++;
    }
}


ISR(USART0_RX_vect)
{
  unsigned char nextChar;
 
  // Daten aus dem Puffer lesen
  nextChar = UDR0;
  if( uart_str_complete == 0 ) {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
 
    // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
        nextChar != '\r' &&
        uart_str_count < UART_MAXSTRLEN - 1 ) {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

int main()
{
  uart_init();
  sei();

  uart_putc('k');
  uart_puts("T\n");
  
  while(1)
  {
    if(uart_str_complete==1)
    {
      uart_puts((char*)uart_string);
      uart_str_complete=0;
    }
    
  }

   return 0;
}

[Karl H. (kbuchegg)]

Bastler07 schrieb:
> der aufgräumte code, allerdings bleit das problem gleich
> der atmega kann zum terminal senden, aber nicht empfangen

Wie testest du?
Druck auf Return vergessen?

Füg hier mal ein Echo ein

> ISR(USART0_RX_vect)
> {
>   unsigned char nextChar;
>
>   // Daten aus dem Puffer lesen
>   nextChar = UDR0;

    uart_putc( nextChar );

>   if( uart_str_complete == 0 ) {  // wenn uart_string gerade in
> Verwendung, neues Zeichen verwerfen
>
>     // Daten werden erst in string geschrieben, wenn nicht
> String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
>     if( nextChar != '\n' &&
>         nextChar != '\r' &&
>         uart_str_count < UART_MAXSTRLEN - 1 ) {
>       uart_string[uart_str_count] = nextChar;
>       uart_str_count++;
>     }
>     else {
>       uart_string[uart_str_count] = '\0';
>       uart_str_count = 0;
>       uart_str_complete = 1;
>     }
>   }
> }

Jetzt schickt der µC gleich alles zurück, was über die UART reinkommt 
und du tippst nicht mehr im Dunkeln.

[Bastler07 (Gast)]

hi
klasse, das war schonmal ein super hinweis, nun geht es fast komplett

ich schick test\n hin und er schickt mir test\n zurück (durch die neu 
eingefügte ausgabe, aber nicht über den interrupt)

dann schicke ich nach kurzer zeit nochmal hallo hin

dann schickt er über interrupt folgendes:
hallotest\nhal

das erste hallo kommt noch von der neuen Ausgabe, der weitere Teil ist 
dann der korrekte Teil, allerdings der vorige noch dabei und auf 10 
Zeichen begrenzt

Er wartet also immer, bis die vollen 10 Zeichen empfangen wurde und gibt 
dann erst das uart_str_complete=1 raus

Wieso nimmt er also die \n oder \r zum beenden meines Strings nicht 
wahr? Kann das am Terminalprogramm liegen? Ich nutze HTerm und shcicke 
ASC

Viele Dank

[Karl H. (kbuchegg)]

Wie genau schickst du \n ?

Das ist die C Schreibweise für Return (die große Taste mit dem Haken 
drauf) und nicht für die beiden Tasten '\' und dann 'n'.

[Frank M. (ukw) (Moderator)]

Karl Heinz Buchegger schrieb:
> Wie genau schickst du \n ?
>
> Das ist die C Schreibweise für Return (die große Taste mit dem Haken
> drauf) und nicht für die beiden Tasten '\' und dann 'n'.

Das ist nicht ganz korrekt. Standardmäßig schickt ein 
Terminal-Emulationsprogramm beim Drücken der RETURN-Taste ein CR, was 
einem '\r' entspricht. Dieses sollte man "echoen" mit "\r\n" (CRLF, also 
Wagenrücklauf mit anschließendem Zeilenvorschub). Wenn man nur das '\r' 
als Echo zurückschickt, dann hat man den hässlichen Effekt, dass der 
Cursor lediglich an den Anfang der Zeile gestellt wird, aber keine neue 
Zeile erzeugt wird.

Ein '\n' kann man in einer Terminal-Emulation nur mit STRG-J schicken, 
das entspricht dem LF (Hex 0A) und damit dem '\n'.

Wie gesagt, das gilt für die Standard-Konfiguration einer 
Terminal-Emulation. Einige kann man auch umstellen, dass beim Drücken 
der RETURN-Taste ein CRLF ("\r\n") oder nur ein LF ('\n'= geschickt 
wird. Würde ich aber nicht umstellen in der Konfiguration, denn beim 
Wechsel auf ein anderes Programm oder PC hat man das Problem wieder.

Man muss sich einfach dran gewöhnen, dass der PC ein CR schickt und man 
das als CRLF "echoen" sollte.

Gruß,

Frank

[Frank M. (ukw) (Moderator)]

Bastler07 schrieb:
> der aufgräumte code, allerdings bleit das problem gleich
> der atmega kann zum terminal senden, aber nicht empfangen

Eins fällt mir direkt auf: Du schneidest beim Empfang \r und auch \n ab, 
d.h. sie stehen nicht im Empfangspuffer uart_string. Beim Zurücksenden 
von uart_string vergisst du aber, diese Zeichen wieder zurückzusenden. 
Am einfachsten machst Du das in main durch:

     uart_puts((char*)uart_string);
     uart_puts("\r\n");               // CRLF hinzufügen!

Und nochmal mein Hinweis, dass Du uart_str_count direkt als 
static-Variable in der ISR definieren kannst, dann brauchst Du auch 
keine volatile-Deklaration, was Dein Programm auf jeden Fall ein 
Stückchen "effizienter" macht.

Also:

ISR(USART0_RX_vect)
{
    static uint8_t uart_str_count;
    ...

Gruß,

Frank

[Bastler07 (Gast)]

ah, ich kann es im terminalprogramm einstellen
bei "Send on enter: CR" funktioniert es super

danke, die weiteren Tipps werde ich noch einbauen