UART Receive Transmit Via ein Puffer und behandlung mit Inte

/**************************************************************

*                                                              *

*                         UART.c                                *

*                                                              *

***************************************************************/

/* Include-Dateien

   -----------------*/

#include <avr/io.h>

#include <avr/interrupt.h>

/* UCR - UART Control Register: Bit Definitionen

   -----------------------------------------------------------*/

#define     RXCIE    0x80    // Bit 7

#define     TXCIE    0x40    // Bit 6

#define     UDRIE    0x20    // Bit 5

#define     RXEN     0x10    // Bit 4

#define     TXEN     0x08    // Bit 3

#define     CHR9     0x04    // Bit 2

#define     RXB8     0x02    // Bit 1

#define     TXB8     0x01    // Bit 0

/* USR - UART Status Register: Bit Definitionen

    ---------------------------------------------------------*/

#define     RXC     0x80    // Bit 7

#define     TXC     0x40    // Bit 6

#define     UDRE    0x20    // Bit 5

#define     FE      0x10    // Bit 4

#define     OVR     0x08    // Bit 3

/* UBRR - UART Baudrate Register: Baud Definitionen fuer 4MHz

    ---------------------------------------------------------*/

#define     BAUD_1200     208

#define     BAUD_2400     103

#define     BAUD_9600     25

#define     BAUD_19200    12

/* UART Daten-Puffer Definitionen

    ------------------------------*/

#define BUFFER_SIZE     8     // Modulo 2 Groesse: nur 2,4,8,16,32 Bytes

#define BUFFER_MASK     (BUFFER_SIZE-1)

/* Allgemeine typ-Definitionen

    -----------------------------------------------------------*/

typedef enum{ FALSE=0, TRUE=1} Boolean_t ;

typedef struct{ unsigned char UartData[ BUFFER_SIZE ];

                unsigned char NumberOfBytes;

                unsigned char UartStatus; } Uart_t;

/* Static Variables

   -------------------*/

static unsigned char                RxBuf[ BUFFER_SIZE ];

static volatile unsigned char       RxProducer;  // Empfang: Int-Service ist der Producer

static volatile unsigned char       RxConsumer;  // Empfang: Hauptprogramm ist Consumer

static unsigned char                TxBuf[ BUFFER_SIZE ];

static volatile unsigned char       TxProducer;  // Senden: Hauptprogramm ist der Producer

static volatile unsigned char       TxConsumer;  // Senden: Int-Service ist Consumer

/* Funktion-Prototypen

   ----------------------------*/

void InitUart( unsigned char baudrate );

Boolean_t ReceiveData( Uart_t * Data );

Boolean_t TransmitData( Uart_t * Data );

void Delay( void );

/* Input Pins, Port B:               sfrb PINB    = 0x16;

   Data Direction Register, Port B:  sfrb DDRB    = 0x17;

   Data Register, Port B:            sfrb PORTB   = 0x18; */

void Delay( void )  // warte zeit

{

  unsigned int i= 0x7FFF;

  while(--i);

}

/* Main - ein einfaches Anwendungsbeispiel fuer UART und Timer

   -------------------------------------------------------------*/

void C_task main( void )

{

    Uart_t UartData;

    DDRB  = 0xFF ; // Konfiguriert Port B als Ausgang

    PORTB = 0xAA;

    InitUart( BAUD_9600 );     // Baudrate = 9600 Baud bei 4MHz Quarz

    _SEI();                      // Freigabe aller Interrupts => Enable UART Interrupts

    for( ;; )                  // Endlos-Schleife

    {

        if( ReceiveData( & UartData ) )

        {

          TransmitData( & UartData );     // Echo der empfangenen Bytes

        }

        PORTB++; // Nur zum Testen Led schalten

        Delay(); // damit das Programm nicht nur die UART Daten abfragt

    }

}

/* Initialisierung der UART

    ------------------------------*/

void InitUart( unsigned char baudrate )

{

    UBRR = baudrate;               // Baudrate setzen

                                  // Freigabe der UART Interrupts

    UCR =  TXEN | RXEN | RXCIE;   // ==> Senden/Empfangen/Empf.INT

    RxConsumer     = 0;            // Ruecksetzen der Puffer-Index

    RxProducer     = 0;

    TxConsumer     = 0;

    TxProducer     = 0;

}

/*  Empfangs-Interrupt Handler

    --------------------------- */

interrupt [UART_RX_vect] void UartRxIntHandler( void )

{

    unsigned char data;

    data = UDR;                 // Lesen der Empfangsdaten

    RxBuf[RxProducer] = data;   // Empfangenes Byte in Puffer ablegen

    RxProducer++;               // Bufferindex setzen

    RxProducer &=BUFFER_MASK;   // Index begrenzen und evtl. auf Puffer-Anfang

    if (RxProducer == RxConsumer )

    {

        // Fehler! Ueberlauf Empfangspuffer

    }

    if( data =='\r') Wenn return Taste gedruckt

    {

     RxProducer == RxConsumer ; // Überlauf simulieren

     // UCR=~RXCIE; //oder der   interrupt disable

    }

}

/*  Sende-Interrupt Handler

    --------------------------- */

interrupt [UART_UDRE_vect] void UART_TX_interrupt( void )

{

    // Test ob noch nicht fertig mit Senden

    if ( TxConsumer != TxProducer  ) // Nein, weiter machen mit senden

    {

        ++TxConsumer;               // Pufferindex aktualisieren

        TxConsumer &=BUFFER_MASK;   // Index begrenzen und evtl. auf Puffer-Anfang

        UDR = TxBuf[TxConsumer];    // Uebergabe eines Bytes

     }

        else  // fertig ,senden beenden

    {

        UCR &= ~UDRIE; // Disable UDRE interrupt

    }

}

/* UART Empfangsfunktion

   --------------------- */

Boolean_t ReceiveData( Uart_t * Data )

{

    unsigned char i=0;

    // Schleife zur Uebergabe der empfangenen Daten

    while (( RxConsumer != RxProducer ) && ( i < BUFFER_SIZE ) )

    {

       Data->UartData[i++] = RxBuf[RxConsumer++];

       RxConsumer &=BUFFER_MASK;   // Consumer-Index begrenzen und evtl. auf Puffer-Anfang

    }

    Data->NumberOfBytes = i ;

    if( i ) return TRUE ;

     else return FALSE ;

}

/* Sendefunktion

   --------------------- */

Boolean_t TransmitData( Uart_t * Data )

{

    unsigned char i=0;

    while (( i < Data->NumberOfBytes ) && ( i < BUFFER_SIZE ) )// Uebergabe Sendendaten

    {

       TxBuf[TxProducer++] = Data->UartData[i++] ;

       TxProducer &=BUFFER_MASK;   // Producer-Index begrenzen und evtl. auf Puffer-Anfang

    }

    UDR = TxBuf[TxConsumer];        // Senden Anstossen

    ++TxConsumer;

    TxConsumer &=BUFFER_MASK;   // Consumer-Index begrenzen

    UCR |=  UDRIE ;

    Data->NumberOfBytes = 0;

    return TRUE ;

}