Atmega88P USART Kommunikation funktioniert nicht

[A. B. (developer_x)]

Liebes Forum,
ich hänge hier fest und weiß einfach nicht warum:
Ich nutze einen Atmega88P mit einem MAX232 um Daten per UART an meine 
RS232 Schnittstelle an den PC zu senden. Ich habe ein kleines 
Fertigbauteil aus China, auf dem mein MAX232 sitzt, und mit dem ich 
früher schon prima arbeiten konnte, in Assembler, nun will ich in C 
arbeiten es will aber einfach nicht klappen. Auf dem Fertigbauteil (so 
ne Platine) gibt es auch LEDs die blinken, wenn Daten übertragen werden 
(RXD und TXD).

Zum Ablesen der eingehenden Daten benutze ich HTerm.

Das ist mein Code:

#include <avr/io.h>
#include <stdlib.h>

#define F_CPU 8000000
                         
#define BAUD 9600      
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif

void uart_init(void)
{
  UBRR0H = (unsigned char)(UBRR_VAL >> 8);
  UBRR0L = (unsigned char)(UBRR_VAL & 0xFF);
 
  UCSR0B |= (1<<TXEN0);  // UART TX einschalten
  UCSR0C = (1<<USBS0)|(3<<UCSZ00);
}

int uart_putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR0 = c;                      /* sende Zeichen */
    return 0;
}
 


int main (void) 
{
   char c;
 
   uart_init();
 
   while (1) 
   {
       for (uint8_t i=0; i<=255; ++i) 
       {
          c = i;
          uart_putc( c );
          // verkuerzt: uart_putc( i + '0' );
       }
   }
 
   return 0; // never reached 
 
}

In meinem Terminalprogramm kommt nix an, das RXD Lämpchen auf meiner 
Platine blinkt fleißig, also dachte ich, wie wärs wenn du das RXD Kabel 
des Bauteils an den TXD des Atmegas dran machst und das TXD Kabel des 
Bauteils an den RXD des Atmegas: Dann kommt was in meinem Terminal an, 
was aber immer abwechselnd "000" bzw. "128" ist. Ich hab geguckt, aber 
in meinem HTerm habe ich alle Einstellungen so gelassen wie Sie sind 
außer die Baudrate auf 9600 zu setzen.

Kann mir jemand sagen, was ich falsch mache?

Danke,
m.f.G.: K.R.

[stefan us (Gast)]

Klemme den AVR erstmal ab und verbinde am China Modul RxD mit TxD. Dann 
schau mit Hterm, ob das, was du sendest auch wieder zurück kommt. Wenn 
nicht, könnte dieses teil defekt sein.

Ansonsten stimmt vielleicht die Übertragungsrate nicht. Schwingt der 
Quarz wirklich 8Mhz? hast Du vieleicht versehentlich die Fuse CLKDIV8 
gesetzt.

Dan kann man mit einer blinkenden LED leicht testen:

while (1) {
  led an machen;
  _sleep_ms(1000);
  led aus machen;
  _sleep_ms(1000);
}

Die LED muss immer abwechselnd eine Sekunde an und aus sein. Wenn nicht, 
stimmt etwas mit dem Taktgeber nicht.

[A. B. (developer_x)]

1. Wenn ich RX mit TX vom Chinamodul verbinde, kommt das am PC an was 
ich absende, daran liegts nicht.

2. Ja, das war in der Tat gesetzt, ich habs weggemacht

3. Ich habe keinen externen oszillator sondern der internen, und mein 
avr studio sowie ein test mit den leds bestätigt, 8 Mhz
Seitdem ich den Fuse verändert habe kommt in Hterm mal "000" mal "192" 
an, aber wie gesagt nichts sinnvolles.

Danke für deine hilfe, würde dir noch was einfallen woran es liegen 
könnte?

[Bernhard F. (bernhard_fr)]

K. R. schrieb:

>

>   UCSR0C = (1<<USBS0)|(3<<UCSZ00);
>

2 Stopbits ? ist das gewollt?

> Ich hab geguckt, aber
> in meinem HTerm habe ich alle Einstellungen so gelassen wie Sie sind
> außer die Baudrate auf 9600 zu setzen.

HTerm ist per Default auf einem Stopbit.

Ich weiß zwar nicht ob das schon weiterhilft, aber das fiel mir nur 
gerade spontan auf.

[A. B. (developer_x)]

Du hast recht, ich habe jetzt hterm auf 2 umgestellt, hat nicht 
geklappt,

Dann habe ich hterm wieder auf 1 stopbit umgestellt und es mit folgender 
ersatzzeile versucht:

UCSR0C = (1<<UMSEL01)|(1<<UCSZ01)|(1<<UCSZ00);

Klappt aber auch nicht :?

Noch jemand eine Idee?

Danke für eure Hilfe,
m.f.G.: K.R.

[Stefan E. (sternst)]

Bernhard F. schrieb:
> Ich weiß zwar nicht ob das schon weiterhilft

Mehr Stopbits zu senden, als der Empfänger erwartet, ist nie ein 
Problem.


@ K. R.:
Mach mal eine Pause (1ms) nach dem uart_init().

[Marc V. (Firma: Vescomp) (logarithmus)]

K. R. schrieb:
> Dann habe ich hterm wieder auf 1 stopbit umgestellt und es mit folgender
> ersatzzeile versucht:
> UCSR0C = (1<<UMSEL01)|(1<<UCSZ01)|(1<<UCSZ00);
> Klappt aber auch nicht :?

 Und auch das sollst du nicht tun. ATMEL sagt, dass UMSEL01=1 und
 UMSEL00=0 RESERVED ist.

[Jens K. (blauzahnmeister)]

Hallo.
Ist evt. die Fuse  am MC gesetzt, die Deine Clock durch 8 dividiert *
Dann ist einfach alles was Du tust 8 fach zu langsam...

[A. B. (developer_x)]

Nein, die Fuse ist nicht gesetzt, war, jetzt nicht mehr.

Das ist mein aktueller Code, ich warte jetzt 2 ms nach dem 
Initialisieren,
und weiß ehrlich gesagt net was ich ganz konkret im UART Control 
Register denn sonst einstellen soll:

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

#define F_CPU 8000000
                         
#define BAUD 9600      
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif

void uart_init(void)
{
  UBRR0H = (unsigned char)(UBRR_VAL >> 8);
  UBRR0L = (unsigned char)(UBRR_VAL & 0xFF);
 
  UCSR0B |= (1<<TXEN0);  // UART TX einschalten
  UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);  // Asynchron 8N1 
}

int uart_putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR0 = c;                      /* sende Zeichen */
    return 0;
}
 
int main (void) 
{
   char c;
 
   uart_init();
   _delay_ms(2);
   while (1) 
   {
       for (uint8_t i=0; i<=255; ++i) 
       {
          c = i;
          uart_putc( c );
          // verkuerzt: uart_putc( i + '0' );
       }
   }
 
   return 0; // never reached 
 
}

Das hier im Forum genannte Tutorial empfiehlt aber UMSEL zu ändern:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART#UART_initialisieren
Dort heißt es:

/* UART-Init Bsp. ATmega16 */
 
void uart_init(void)
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
 
  UCSRB |= (1<<TXEN);  // UART TX einschalten
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1 
}

Nur das URSEL beim ATmega88P UMSEL00 heißt.

Ich bedanke mich erstmal für euer Engagement, hat jemand noch eine Idee?
m.f.G. K.R.

[Frank M. (ukw) (Moderator)]

K. R. schrieb:
> Nur das URSEL beim ATmega88P UMSEL00 heißt.

Wie kommst Du denn auf dieses schmale Brett?

[Stefan E. (sternst)]

K. R. schrieb:
> Nur das URSEL beim ATmega88P UMSEL00 heißt.

Nein, das sind zwei grundverschiedene Bits, die rein gar nichts 
miteinander zu tun haben.

[Frank M. (ukw) (Moderator)]

Hier mal einige portable gestaltete UART-Funktionen, die auf so ziemlich 
jedem ATmega funktionieren:

#define BAUD  9600L
#include <util/setbaud.h>

#ifdef UBRR0H

#define UART0_UBRRH                             UBRR0H
#define UART0_UBRRL                             UBRR0L
#define UART0_UCSRA                             UCSR0A
#define UART0_UCSRB                             UCSR0B
#define UART0_UCSRC                             UCSR0C
#define UART0_UDRE_BIT_VALUE                    (1<<UDRE0)
#define UART0_UCSZ1_BIT_VALUE                   (1<<UCSZ01)
#define UART0_UCSZ0_BIT_VALUE                   (1<<UCSZ00)
#ifdef URSEL0
#define UART0_URSEL_BIT_VALUE                   (1<<URSEL0)
#else
#define UART0_URSEL_BIT_VALUE                   (0)
#endif
#define UART0_TXEN_BIT_VALUE                    (1<<TXEN0)
#define UART0_UDR                               UDR0
#define UART0_U2X                               U2X0
        
#else

#define UART0_UBRRH                             UBRRH
#define UART0_UBRRL                             UBRRL
#define UART0_UCSRA                             UCSRA
#define UART0_UCSRB                             UCSRB
#define UART0_UCSRC                             UCSRC
#define UART0_UDRE_BIT_VALUE                    (1<<UDRE)
#define UART0_UCSZ1_BIT_VALUE                   (1<<UCSZ1)
#define UART0_UCSZ0_BIT_VALUE                   (1<<UCSZ0)
#ifdef URSEL
#define UART0_URSEL_BIT_VALUE                   (1<<URSEL)
#else
#define UART0_URSEL_BIT_VALUE                   (0)
#endif
#define UART0_TXEN_BIT_VALUE                    (1<<TXEN)
#define UART0_UDR                               UDR
#define UART0_U2X                               U2X

#endif //UBRR0H

static void
uart_init (void)
{
    UART0_UBRRH = UBRRH_VALUE;                                                                      // set baud rate
    UART0_UBRRL = UBRRL_VALUE;

#if USE_2X
    UART0_UCSRA |= (1<<UART0_U2X);
#else
    UART0_UCSRA &= ~(1<<UART0_U2X);
#endif

    UART0_UCSRC = UART0_UCSZ1_BIT_VALUE | UART0_UCSZ0_BIT_VALUE | UART0_URSEL_BIT_VALUE;
    UART0_UCSRB |= UART0_TXEN_BIT_VALUE;                                                            // enable UART TX
}

static void
uart_putc (unsigned char ch)
{
    while (!(UART0_UCSRA & UART0_UDRE_BIT_VALUE))
    {
        ;
    }

    UART0_UDR = ch;
}

static void
uart_puts (char * s)
{
    while (*s)
    {
        uart_putc (*s);
        s++;
    }
}

static void
uart_puts_P (PGM_P s)
{
    uint8_t ch;

    while ((ch = pgm_read_byte(s)) != '\0')
    {
        uart_putc (ch);
        s++;
    }
}

Viel Spaß,

Frank

[A. B. (developer_x)]

Wie ich darauf komme?

http://www.atmel.com/images/doc2553.pdf
Seite 8 Tabelle unten.

[Bernhard F. (bernhard_fr)]

O.K. habe mal deinen Code ins Studio geworfen und durchlaufen lassen.

Ergebnis: 4 Warnings mit entsprechenden Messages.

alle sagen "int overflow in Expression" bzw. "in expansion of Macro"

Dazu kommt noch: Wenn irgendwelche undefinierten Zeichen ankommen ist es 
meist die Baudrate.

Im Register steht auch eine 0x0162, was ja wohl vollkommen daneben ist.

Versuch mal bitte statt

  UBRR0H = (unsigned char)(UBRR_VAL >> 8);
  UBRR0L = (unsigned char)(UBRR_VAL & 0xFF);

einfach

UBRRO = 51;

und dazu eventuell noch den vorgeschlagenen Delay nach der 
Initialisierung.
Was ergibt das ?

[Frank M. (ukw) (Moderator)]

K. R. schrieb:
> Wie ich darauf komme?
>
> http://www.atmel.com/images/doc2553.pdf
> Seite 8 Tabelle unten.

Da steht nichts davon, dass URSEL nun UMSEL00 heisst. Da steht nur, dass 
die alte Position für URSEL mittlerweile für andere Zwecke genutzt wird.

[A. B. (developer_x)]

1. Der Code von Frank M funktioniert direkt.

2. Wenn ich UBRR0 = 51 setze klappt es auch.

Erstmal danke für die Antworten, jetzt klappts wuhu! :)

Aber: Warum? Habe ich in das Baudraten register die Baudrate falsch 
eingetragen?

[Bernhard F. (bernhard_fr)]

Gerade den Beitrag von Frank M. gesehen.

Wer mag mal erkären:
- warum dort die Baudrate als 9600_l_ definiert ist?
- Was das damit zu tun hat, dass 9600 x 16 größer als 65535 ist ?
- Was "int overflow" in diesem Zusammenhang dem Anwender sagen sollte?

[Stefan E. (sternst)]

Bernhard F. schrieb:
> O.K. habe mal deinen Code ins Studio geworfen und durchlaufen lassen.
>
> Ergebnis: 4 Warnings mit entsprechenden Messages.

In der Tat, da fehlt ein L an der Baudrate.

#define BAUD 9600L

Ohne dem läuft z.B. (BAUD*16) über.

[Frank M. (ukw) (Moderator)]

K. R. schrieb:
> 1. Der Code von Frank M funktioniert direkt.

Freut mich. Das Schöne daran ist, dass der nicht nur auf dem ATmega88 
funktioniert.

> Aber: Warum? Habe ich in das Baudraten register die Baudrate falsch
> eingetragen?

Dann stimmte wohl tatsächlich etwas mit dem Baudratenregister nicht. Ja, 
das L fehlte :-)

Deine Methode zur Berechnung ist auch veraltet. Aktuell sollte man 
besser die Preprocessor-Konstante BAUD setzen und das Include 
<util/setbaud.h> benutzen. Durch Unterstützung von U2X werden dann auch 
die Werte benutzt, die am besten zu Deiner F_CPU passen.

[Thomas E. (thomase)]

Bernhard F. schrieb:
> Wer mag mal erkären:
> - warum dort die Baudrate als 9600_l_ definiert ist?
> - Was das damit zu tun hat, dass 9600 x 16 größer als 65535 ist ?
> - Was "int overflow" in diesem Zusammenhang dem Anwender sagen sollte?

Gerechnet wird mit 16-Bit-Integer.
16-Bit-Integer geht von -32768 bis 32767. Alles, was über diesen 
Zahlenraum hinausgeht, bedingt einen Overflow.

9600 * 16 ist, ob im Kopf oder auf dem Taschenrechner, 153600.
In 16-Bit-Integer jedoch 22528.
Netterweise gibt es dann besagte Warnung. Ignoriert man die, 
funktioniert es nicht.

Macht man in der Berechung einen Faktor long, wird alles mit long 
gerechnet. Also von -2147483684 bis 2147483683.

9600L * 16 = 153600. Dann passt das.

mfg.

[A. B. (developer_x)]

Gut danke an alle!