UART läuft nicht auf einem AVR

[Markus (Gast)]

guten abend,
ich habe ein Problem mit dem UART auf einem ATMega328 welcher auf einem 
Arduino Board sizt.
Dieser möchte nicht funktionieren.

main.c:

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "defines.h"
#include "uart/uart.h"

int main(void)
{
    DDRB |= (1 << PINB5);
    PORTB &= ~(1 << PINB5);
    uart_init(MYUBRR);
    sei();
    while(1)
    {
        uart_sendStringWait("Test");
        PORTB ^= (1 << PINB5);
        _delay_ms(1000);
    }
}

uart.c:

void uart_init(unsigned int ubrr)
{  
  /* Set baud rate */
  UBRR0H = ubrr >> 8;
  UBRR0L = ubrr & 0xFF;

  /* Enable receiver and transmitter */
  UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0); // RXCIE0: RX Interrupt

  /* Set frame format: 8data, 1stop bit */
  UCSR0C = (1<<UCSZ00)|(1<<UCSZ01);
}

UART_ERROR uart_sendStringWait(char *s)
{
    UART_ERROR ret;
    if(1 != (UCSR0B & (1<<RXEN0)))
    {
        ret = UART_TX_NOT_ENABLED;
    }
    else
    {
      while(*s != 0x00)
      {
            ret = uart_transmit(*s);
            if(UART_NO_ERROR == ret)
            {
                s++;
            }
      }
        ret = UART_NO_ERROR;
    }
    return ret;
}

static UART_ERROR uart_transmit( unsigned char data );
static UART_ERROR uart_transmit( unsigned char data )
{
    UART_ERROR ret = UART_UDR_NOT_FREE;
    if(UCSR0A & (1<<UDRE0))
    {
        UDR0 = data;
        ret = UART_NO_ERROR;
    }

    return ret;
}

Angeschlossen habe ich dies über einem FTDI zum PC.

Verbunden (Arduino <-> FTDI)
TX <-> RX
RX <-> TX
GND <-> GND

Auch am FTDI an für sich sehe ich nicht das UART daten gesendet bzw. 
empfangen worden sind.
Sende ich etwas vom PC, sehe ich eine LED am FTDI kurz aufblitzen 
(sprich es ist etwas angekommen)
Die LED toggelt. Sprich der Code an für sich läuft.

Aber den Fehler im Code für den UART sehe ich nicht.

[holger (Gast)]

Du wartest nicht bis das Byte in UDR0 auch gesendet wurde. Das geht 
nicht in SOFORT. Das dauert. Dann rennst du das nächste mal in 
uart_transmit() und fliegst gleich mit einem Fehler raus.

[S. Landolt (Gast)]

> if(1 != (UCSR0B & (1<<RXEN0)))
? 'bitwise and', müsste also (1 != 16) sein, oder?

[Markus (Gast)]

holger schrieb:
> Du wartest nicht bis das Byte in UDR0 auch gesendet wurde. Das geht
> nicht in SOFORT. Das dauert. Dann rennst du das nächste mal in
> uart_transmit() und fliegst gleich mit einem Fehler raus.

Warte jetzt direkt nach dem senden bit UDR0 wieder frei ist

static UART_ERROR uart_transmit( unsigned char data )
{
    UART_ERROR ret = UART_UDR_NOT_FREE;
    if(UCSR0A & (1<<UDRE0))
    {
        UDR0 = data;
        ret = UART_NO_ERROR;
        while(!(UCSR0A & (1<<UDRE0)))
    }
    return ret;
}

aber auch jetzt sehe passiert nichts.

[Stefan F. (Gast)]

Bevor du das UDR Register beschreibst, musst du warten dass es frei 
wird. Nicht danach.

Was mir negativ aufgefallen ist:
> UCSR0B |= ein paar Bits
> UCSR0C = ein paar Bits

Warum einmal |= und direkt darunter = ? Beides könnte man plausibel 
begründen, aber dieser Mischmasch gefällt mir gar nicht.

[Markus (Gast)]

Stefan ⛄ F. schrieb:
> Bevor du das UDR Register beschreibst, musst du warten dass es frei
> wird. Nicht danach.

Ich warte ja indirekt, indem ich nur das zeichen schreibe wenn UDRE0 
auch frei ist.
Aber auch wenn ich davor (mit der while) warte, passiert nichts

static void uart_transmit( unsigned char data )
{
    while(!(UCSR0A & (1<<UDRE0))){}
    UDR0 = data;
}

[Stefan F. (Gast)]

Deine sendStringWait Funktion kann nicht senden. Hast du den vorherigen 
Hinweis beachtet und es korrigiert?

S. Landolt schrieb:
>> if(1 != (UCSR0B & (1<<RXEN0)))
> ? 'bitwise and', müsste also (1 != 16) sein, oder?

[Stefan F. (Gast)]

Gehe Schrittweise vor, wenn du den Fehler nicht auf die Schnelle 
erkennst. Ändere deine Hauptschleife in:

    while(1)
    {
        UDR0 = 'x';
        PORTB ^= (1 << PINB5);
        _delay_ms(1000);
    }

Wenn das nicht geht, haben wir viel weniger Zeilen zu untersuchen.

Und wenn es geht, geht kommt der nächste Schritt:

    while(1)
    {
        uart_transmit('y');
        PORTB ^= (1 << PINB5);
        _delay_ms(1000);
    }

Blinkt die LED richtig im 1s Intervall?

Wenn es geht kommt der nächste Schritt:

    while(1)
    {
        uart_sendStringWait("z");
        PORTB ^= (1 << PINB5);
        _delay_ms(1000);
    }

[holger (Gast)]

S. Landolt schrieb:
>> if(1 != (UCSR0B & (1<<RXEN0)))
> ? 'bitwise and', müsste also (1 != 16) sein, oder?

Wobei die Abfrage auch ziemlich sinnfrei ist wenn man das darunter 
liest:

        ret = UART_TX_NOT_ENABLED;

Es wird abgefragt ob RX Enabled ist. Einfach erst einmal den ganzen Kram 
weglassen und schauen ob TX funktioniert. Dann weiß man auch ob die 
Baudrate stimmt usw.

[Markus (Gast)]

Stefan ⛄ F. schrieb:
> Deine sendStringWait Funktion kann nicht senden. Hast du den vorherigen
> Hinweis beachtet und es korrigiert?
>
> S. Landolt schrieb:
>>> if(1 != (UCSR0B & (1<<RXEN0)))
>> ? 'bitwise and', müsste also (1 != 16) sein, oder?

Ja, das hatte ich auch schonmal auskommentiert.
Aber auch das hat nichts gebracht.

Habe was anderes gefunden.
Direkt nach uart_init habe ich den receive buffer gelöscht

void uart_flush(void)
{
    uint8_t dummy;
    while (UCSR0A & (1<<RXC0))
    {
        dummy = UDR0;
    }
}

Warum das jetzt aber das Senden geholfen hat, verstehe ich nicht.

[holger (Gast)]

UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0); // RXCIE0: RX Interrupt

Du hast einen RX Interrupt aktiv geschaltet ohne Interruptroutine.
Das endet in einer Endlosschleife.

[Stefan F. (Gast)]

holger schrieb:
> Du hast einen RX Interrupt aktiv geschaltet ohne Interruptroutine.

Das erklärt, warum

Markus schrieb:
> Direkt nach uart_init habe ich den receive buffer gelöscht
> Warum das jetzt aber das Senden geholfen hat, verstehe ich nicht.

Jetzt wird die (nicht existierende) Interrupt-Routine nicht aufgerufen 
-> keine Endlosschleife.

[Markus (Gast)]

holger schrieb:
> UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0); // RXCIE0: RX Interrupt
>
> Du hast einen RX Interrupt aktiv geschaltet ohne Interruptroutine.
> Das endet in einer Endlosschleife.

Tatsache.
durch das flush habe ich den Buffer geleert und es ging normal.
Habe jetzt mal ganz viele Daten gesendet und es funktioniert wieder 
nicht.
Durch das rausnehmen des Interrupts ist das Problem nicht mehr

[Markus (Gast)]

Jetzt habe ich aber noch einmal eine Frage.
Wie programmiert ihr euer UART?
Ich sehe momentan zwei wege.

So wie es jetzt momentan implementiert ist.

Sprich aus einer Funktion rufe ich die UART funktion auf um etwas zu 
senden. Erst wenn dies gesendet worden ist, geht es mit der eigentlichen 
Funktion weiter.

Eine andere Möglichkeit wäre ein buffer zu erstellen, welche ich nur 
befülle.
Also meine Funktion füllt den Buffer und macht mit der eigentlichen 
Arbeit weiter. Das senden wird dann vom UART-Modul selber übernommen 
(Also mit Interrupts dann)

[Stefan F. (Gast)]

Markus schrieb:
> Wie programmiert ihr euer UART?

Kommt auf die Anforderungen der Anwendung an. Immer nur so komplex wie 
nötig. Ich sende oft ohne Puffer, aber empfange mit Puffer und 
Interrupt.

Dies ist meine Kopiervorlage mit der ich meistens neue Projekte beginne: 
http://stefanfrings.de/avr_hello_world/index.html

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Ich lasse immer so viel wie möglich von der Hardware erledigen. Um 
alles, was die Hardware macht, brauche ich mich in der Software nicht zu 
kümmern. Also UART immer komplett interruptgesteuert mit Sende- und 
Empfangspuffer. Ich habe mir einmal vernünftige Routinen dafür 
geschrieben, die sich immer wieder recyclen lassen wenn man sie braucht. 
Nachteil: Auf kleinen AVRs brauchen die Puffer unschön viel RAM und dann 
muß man sich da ggf. anpassen wenn man das RAM für andere Dinge braucht.

Kommt halt auch immer drauf an was man möchte. Für kurze Steuerdaten 
braucht man keine Puffer, bei einem zeitkritischen Hauptprogramm, was 
nicht auf das Ende einer Übertragung warten kann, geht's nicht ohne 
Puffer.