Für die AVR-Chips integrierter USART (Universal Serial Asynchronous Receiver Transmitter) stelle ich hier eine Bibliothek mit folgenden Features vor:

Der Multi-Processor Communication Mode ist nicht implementiert.

Download (Zur Verwendung der Dateien siehe Bibliothek: Kein zweites Mal!)

Version 8.8.2012:
- Abweichungen einiger Namen für ATmega8 implementiert
- UsartPutHex() implementiert
- #define der CamelCase-Notation durch inline-Funktionen ersetzt

Konfiguration der Bibliothek
Konstante Wirkung Beispiel
USART_BAUDRATE
USART1_BAUDRATE		 Festlegung der Baudrate.
Zur Berechnung der korrekten Registerbelegung muss außerdem die Konstante F_CPU definiert sein.		 #define USART_BAUDRATE 9600
USART_DOUBLE_SPEED
USAR1T_DOUBLE_SPEED		 Nutzung der Double-Speed-Funktionalität, wenn Konstante definiert. #define USART_DOUBLE_SPEED
USART_PARITY
USART1_PARITY		 Festlegung der Parität.
Folgende Konstanten sind definiert:
PARITY_NONE, PARITY_EVEN, PARITY_ODD		 #define USART_PARITY PARITY_NONE
USART_STOP_BITS
USART1_STOP_BITS		 Festlegung der Anzahl der Stopp-Bits.
Folgende Konstanten sind definiert:
STOP_BITS_1, STOP_BITS_2		 #define USART_STOP_BITS STOP_BITS_1
USART_CHAR_SIZE
USART1_CHAR_SIZE		 Festlegung der Anzahl der Bits pro Zeichen.
Folgende Konstanten sind definiert:
CHAR_SIZE_5, CHAR_SIZE_6, CHAR_SIZE_7, CHAR_SIZE_8		 #define USART_CHAR_SIZE CHAR_SIZE_8
USART_RX_ENABLE
USART1_RX_ENABLE		 Aktivierung des Empfangsteils.
Wird diese Konstante definiert, wird Code für das Empfangteil generiert.		 #define USART_RX_ENABLE
USART_TX_ENABLE
USART1_TX_ENABLE		 Aktivierung des Sendeteils.
Wird diese Konstante definiert, wird Code für das Sendeteil generiert.		 #define USART_TX_ENABLE
Bei aktiviertem Empfangsteil stehen zur Verfügung:
USART_RX_BUFFER_SIZE
USART1_RX_BUFFER_SIZE		 Festlegung der Größe des Empfangspuffers. Diese Konstante legt ebenfalls fest, ob das Empfangsteil interruptgetrieben implementiert wird.
Hat USART_RX_BUFFER_SIZE einen anderen Wert als 0, wird interruptgetrieben mit einem Empfangspuffer der angegebenen Größe gearbeitet.		 #define USART_RX_BUFFER_SIZE 16
USART_GETRRROR
USART1_GETRRROR		 Legt fest, ob Empfangsfehler zwischengespeichert und über die Funktion usart_get_error() zur Verfügung gestellt werden. Bei definierter Konstante wird der Code generiert. #define USART_GETRRROR
Bei aktiviertem Sendeteil stehen zur Verfügung:
USART_TX_BUFFER_SIZE
USART1_TX_BUFFER_SIZE		 Festlegung der Größe des Sendepuffers. Diese Konstante legt ebenfalls fest, ob das Sendeteil interruptgetrieben implementiert wird.
Hat USART_TX_BUFFER_SIZE einen anderen Wert als 0, wird interruptgetrieben mit einem Sendepuffer der angegebenen Größe gearbeitet.		 #define USART_TX_BUFFER_SIZE 16
USART_PRINTF
USART1_PRINTF		 Legt fest, ob Code für die printf-Funktionen generiert wird. Bei definierter Konstante wird der Code generiert. #define USART_PRINTF

 

Ich bevorzuge die CamelCaseNotation (bin halt ein alter Basic-Fan). Deshalb ist jede Funktion sowohl im C-Stil als auch im CamelCase verfügbar.

Funktionsbeschreibung
Bezeichnung Funktion Beispiel
void UsartInit(void)
void usart_init(void)		 Initialisierung der USART in der durch die Konfigurationskonstanten vorgegebenen Einstellung.
Hinweis: Die globale Interrupt wird nicht freigegeben. Dies erfolgt außerhalb der Bibliothek nach Initialisierung aller Komponenten.		 UsartInit();
sei();
uint8_t UsartGetC(void)
uint8_t usart_getc(void)		 Liefert das nächste empfangene Byte. Diese Funktion kehrt erst dann zurück, wenn ein empfangenes Zeichen zur Verfügung steht. Ggf. ist vorher über UsartDataReady zu ermitteln. uint8_t c = UsartGetC();
bool UsartDataReady(void)
bool usart_data_ready(void)		 Prüft, ob empfangene Zeichen vorliegen.
Liefert true, falls mindestens ein Zeichen abgerufen werden kann, ansonsten false.		 if(UsartDataReady())
  c = UsartGetC();
else
  ...
uint8_t UsartGetError(void)
uint8_t usart_get_error(void)		 Liefert Flags für die seit dem letztem Aufruf dieser Funktion aufgetretenen Empfangsfehler. Für die Fehlercodiereung stehen folgende Konstanen zur Verfügung:
USART_NO_ERROR   kein Fehler
USART_BUFFER_OVERFLOW   Empfangspufferüberlauf
USART_FRAME_ERROR   Von der USART erkannter Framing Error
USART_OVERRUN_ERROR   Von der USART erkannte Overrun condition
USART_PARITY_ERROR   Von der USART erkannter Paritätsfehler
uint8_t e;
e = UsartGetError();
if (e & USART_FRAME_ERROR)
  ...
void UsartPutC(const uint8_t data)
void usart_putc(const uint8_t data)		 Übergibt ein Zeichen an die USART zum Senden. Es wird ggf. gewartet bis im Sendepuffer Platz zur Aufnahme des Zeichens ist bzw. bis die USART bereit ist, ein neues Zeichen entgegen zu nehmen. UsartPutC('x');
void UsartPutI(const int data)
void usart_puti(const int data)		 Sendet einen int als ASCII-Ziffernfolge. Benutzt itoa zur Konvertierung. Siehe auch UsartPutC! UsartPutI(-47);
void UsartPutHex(uint8_t data)
void usart_puthex(uint8_t data)		 Sendet ein Byte in hexadezimaler Darstellung (zwei Zeichen).  
void UsartPutS(const char *s)
void usart_puts(const char *s)		 Sendet einen String. Siehe auch UsartPutC! UsartPutC("Hello");
void UsartPutS_p(const char *s)
void usart_puts_p(const char *s)		 Sendet einen String aus dem Programmspeicher. Siehe auch UsartPutC! char pS[] PROGMEM = "Flash";
UsartPutC_p(pS);
void UsartPutS_P(const char *s)
void usart_puts_P(const char *s)		 Sendet eine konstanten String und legt ihn im Programmspeicher ab. Siehe auch UsartPutC! UsartPutC_P("Flash");
void int UsartPrintf(
            const char *fmt, ...)
void int usart_printf(
            const char *fmt, ...)		 Sendet eines formatierten String. Erläuterung der Funktionsweise und der  Formatierungssysmbole. Man beachte die notwenigen Compiler-Switches zur Herstellung der kompletten Funktionsfähigkeit:
"-Wl,-u,vfprintf": per Checkbox in den Projekteigenschaften
"-lprintf_flt": wenn auch Ausgaben von Fließkommazahlen erfolgen sollen.

Siehe auch UsartPutC!		 UsartPrintf("Value %i\n", 17);
void int UsartPrintf_p(
            const char *fmt, ...)
void int usart_printf_p(
            const char *fmt, ...)		 Analog zu UsartPrintf(). Der Formatierungsstring befindet sich im Programmspeicher. char pS[] PROGMEM = "Value %i\n";
UsartPrintf(pS, 17);
void int UsartPrintf_P(
            const char *fmt, ...)
void int usart_printf_P(
            const char *fmt, ...)		 Analog zu UsartPrintf(). Der konstante Formatierungsstring wird im Programmspeicher abgelegt. UsartPrintf_P("Value %i\n", 17);