das mache ich in uart.h:
unter uart_init():
/* * uart.h
*
* Created on: 12.05.2012
* Author: rainer
*/
#ifndef UART_H_
#define UART_H_
#include <avr/io.h>
#include <avr/interrupt.h>
#include "fifo.h" // erklärt im Artikel "FIFO mit avr-gcc"
// FIFO-Objekte und Puffer für die Ein- und Ausgabe
#define BUFSIZE_IN 0x40
uint8_t inbuf[BUFSIZE_IN];
fifo_t infifo;
#define BUFSIZE_OUT 0x40
uint8_t outbuf[BUFSIZE_OUT];
fifo_t outfifo;
//Variable zum Dummy auslesen
uint8_t dummy;
void uart_init (void)
{
uint8_t sreg = SREG;
UBRRH = 0; //Highbyte ist 0
UBRRL = 51; //Lowbyte ist 103 (dezimal)
//-> (Frequenz_in_Hz / (Baudrate * 16)) - 1 <- Quarzfrequenz = 16*1000*1000 Hz!!!!
// Interrupts kurz deaktivieren
cli();
// UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren
// Data mode 8N1, asynchron
UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);
// Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte)
do
{
// UDR auslesen (Wert wird nicht verwendet)
dummy = UDR;
}
while (UCSRA & (1 << RXC));
// Rücksetzen von Receive und Transmit Complete-Flags
UCSRA = (1 << RXC) | (1 << TXC);
// Global Interrupt-Flag wieder herstellen
SREG = sreg;
// FIFOs für Ein- und Ausgabe initialisieren
fifo_init (&infifo, inbuf, BUFSIZE_IN);
fifo_init (&outfifo, outbuf, BUFSIZE_OUT);
}
int uart_putc (const uint8_t c)
{
int ret = fifo_put (&outfifo, c);
UCSRB |= (1 << UDRIE);
return ret;
}
int uart_getc_nowait (void)
{
return fifo_get_nowait (&infifo);
}
uint8_t uart_getc_wait (void)
{
return fifo_get_wait (&infifo);
}
// Einen 0-terminierten String übertragen.
void uart_puts (const char *s)
{
do
{
uart_putc (*s);
}
while (*s++);
}
#endif /* UART_H_ */
hier noch fifo.h:
/* * fifo.h
*
* Created on: 12.05.2012
* Author: rainer
*/
#ifndef FIFO_H_
#define FIFO_H_
#include <avr/io.h>
#include <avr/interrupt.h>
typedef struct
{
uint8_t volatile count; // # Zeichen im Puffer
uint8_t size; // Puffer-Größe
uint8_t *pread; // Lesezeiger
uint8_t *pwrite; // Schreibzeiger
uint8_t read2end, write2end; // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
} fifo_t;
extern void fifo_init (fifo_t*, uint8_t* buf, const uint8_t size);
extern uint8_t fifo_put (fifo_t*, const uint8_t data);
extern uint8_t fifo_get_wait (fifo_t*);
extern int fifo_get_nowait (fifo_t*);
static inline uint8_t
_inline_fifo_put (fifo_t *f, const uint8_t data)
{
if (f->count >= f->size)
return 0;
uint8_t * pwrite = f->pwrite;
*(pwrite++) = data;
uint8_t write2end = f->write2end;
if (--write2end == 0)
{
write2end = f->size;
pwrite -= write2end;
}
f->write2end = write2end;
f->pwrite = pwrite;
uint8_t sreg = SREG;
cli();
f->count++;
SREG = sreg;
return 1;
}
static inline uint8_t
_inline_fifo_get (fifo_t *f)
{
uint8_t *pread = f->pread;
uint8_t data = *(pread++);
uint8_t read2end = f->read2end;
if (--read2end == 0)
{
read2end = f->size;
pread -= read2end;
}
f->pread = pread;
f->read2end = read2end;
uint8_t sreg = SREG;
cli();
f->count--;
SREG = sreg;
return data;
}
void fifo_init (fifo_t *f, uint8_t *buffer, const uint8_t size)
{
f->count = 0;
f->pread = f->pwrite = buffer;
f->read2end = f->write2end = f->size = size;
}
uint8_t fifo_put (fifo_t *f, const uint8_t data)
{
return _inline_fifo_put (f, data);
}
uint8_t fifo_get_wait (fifo_t *f)
{
while (!f->count);
return _inline_fifo_get (f);
}
int fifo_get_nowait (fifo_t *f)
{
if (!f->count) return -1;
return (int) _inline_fifo_get (f);
}
#endif /* FIFO_H_ */