Die serielle Schnittstelle mit den Atmega32: USART

Die serielle Schnittstelle mit den Atmega32: USART
Die Schnittstelle hat die Bezeichnung USART, die für
UNIVERSAL SYNCHRONOUS and ASYNCHRONOUS RECEIVER and TRANSMITTER
steht.
In dieser Abhandlung wird nur die asynchrone Datenübertragung behandelt.
Wie man am PINOUT sieht, befinden sich die Anschlüsse der seriellen Schnittstelle
am PORTD(PD0 und PD1)
Bei serieller Datenübertragung sind diese Portanschlüsse für andere Zwecke
gesperrt. Die serielle Datenübertragung funktioniert auch nicht, wenn der LCD_PORT
auf PORTD eingestellt ist.
Bei der Programmierung sind die folgenden Register von Bedeutung
Die USART-Datenregister UDR
Es handelt sich um 2 physikalische 8-Bit-Register, die mit dem gemeinsamen Namen
UDR angesprochen werden.
Die USART Controll and Status Register UCSRA, UCSRB und USCRC:
UCSRA:
Bit 7 – RXC: USART Receive Complete
Bit 6 – TXC: USART Transmit Complete
Bit 5 – UDRE: USART Data Register Empty
Bit 4 – FE: Frame Error
Bit 3 – DOR: Data OverRun
Bit 2 – PE: Parity Error
Bit 1 – U2X: Double the USART Transmission Speed
Bit 0 – MPCM: Multiprocessor Communication Mode
UCSRB:
Bit 7 – RXCIE: RX Complete Interrupt Enable
Bit 6 – TXCIE: TX Complete Interrupt Enable
Bit 5 – UDRIE: USART Data Register Empty Interrupt Enable
Bit 4 – RXEN: Receiver Enable
Bit 3 – TXEN: Transmitter Enable
Bit 2 – UCSZ2: Character Size
Bit 1 – RXB8: Receive Data Bit 8
Bit 0 – TXB8: Transmit Data Bit 8
UCSRC:
Bit 7 – URSEL: Register Select
This bit selects between accessing the UCSRC or the UBRRH Register. It is read as
one when reading UCSRC. The URSEL must be one when writing the UCSRC.
Bit 6 – UMSEL: USART Mode Select
Bit 5:4 – UPM1:0: Parity Mode
Bit 3 – USBS: Stop Bit Select
Bit 2:1 – UCSZ1:0: Character Size
Bit 0 – UCPOL: Clock Polarity
Die USART-Baudratenregister UBRRH und UBRRL:
Die folgende Tabelle zeigt Einstellwerte für das Baudratengegister bei einer
Oszillatorfrequenz von 8 MHz. Bei Werten unter 256 ist UBRRH=0.
Wir wollen die Schnittstelle nur im asynchronen Modus nutzen:
Beispiel: Die USART-Schnittstelle soll zum asynchronen Senden und Empfangen von
Daten genutzt werden mit 9600 Baud, 8 Datenbits, keine Parität, 1 Stopbit (8N1):
(fosz=8MHz)
Initialisierung der Schnittstelle:
void USART_init(void){
UBRRH=0;
UBRRL=51;
//8N1 Daten
UCSRC|=0x86;
//Empfangen und Senden
UCSRB=0x18;
}
Ein Byte senden:
void USART_putc(uint8_t byte){
while(bit_is_clear(UCSRA,UDRE)); //warten auf Datenregister empty
UDR=byte;
}
Prüfen, ob ein Byte empfangen wurde:
uint8_t USART_byte_avail(void){
if(bit_is_set(UCSRA,RXC))
return 1;
else return 0;
}
Ein Byte empfangen:
uint8_t USART_getc(void){
while(bit_is_clear(UCSRA,RXC));//warten auf Receive Complete
return UDR;
}
void USART_puts(char *s)
/* print string on USART (no auto linefeed) */
{
while (*s!=0) {
USART_putc(*s);
s++;
}
}
Eine Zahl vom Typ float senden:
void USART_putf(float zahl, int sges, int snach){
//Ausgabe einer Fließkommazahl mit sges Gesamtstellen.
//Hiervon sind snach Nachkommastellen.
//Die Nachkollastellen werden gerundet.
char buffer[16];
dtostrf(zahl,sges,snach,buffer);
USART_puts(buffer);
}
Eine Zahl vom Typ int senden:
void USART_puti(int zahl, int sges){
//Ausgabe der Integerzahl zahl formatiert mit sges Stellen
char buffer[17];
uint8_t l=0,n;
char *z=buffer;
itoa(zahl,buffer,10);
while(*z!=0){l++; z++;}//Bufferlänge l
for(n=l;n<sges;n++) USART_putc(' ');
USART_puts(buffer);
}
Eine Zahl vom Typ unsigned int senden:
void USART_putui(unsigned int zahl, int sges){
//Ausgabe der Integerzahl zahl formatiert mit sges Stellen
char buffer[17];
uint8_t l=0,n;
char *z=buffer;
utoa(zahl,buffer,10);
while(*z!=0){l++; z++;}//Bufferlänge l
for(n=l;n<sges;n++) USART_putc(' ');
USART_puts(buffer);
}
Eine Zahl vom Typ unsigned int senden (Leestellen=0):
void USART_putui_0(unsigned int zahl, int sges){
//Ausgabe der Integerzahl zahl formatiert mit sges Stellen
//Leerstellen werden mit 0 aufgefüllt (TSC)
char buffer[17];
uint8_t l=0,n;
char *z=buffer;
utoa(zahl,buffer,10);
while(*z!=0){l++; z++;}//Bufferlänge l
for(n=l;n<sges;n++) USART_putc('0');
USART_puts(buffer);
}
Eine Zahl vom Typ unsigned int hexadezimal senden:
void USART_putui_hex(unsigned int zahl, int sges){
//Ausgabe der nur-positiven Integerzahl zahl formatiert mit sges Stellen
// das Ausgabeformat ist hex (TSC)
char buffer[17];
uint8_t l=0,n;
char *z=buffer;
utoa(zahl,buffer,16);
while(*z!=0){l++; z++;}//Bufferlänge l
for(n=l;n<sges;n++) USART_putc(' ');
USART_puts(buffer);
}
Eine Zahl vom Typ unsigned int binär senden::
void USART_putui_bin(unsigned int zahl, int sges){
//Ausgabe der Integerzahl zahl formatiert mit sges Stellen
// Das Ausgabeformat ist binär. Leerstellen werden mit 0 aufgefüllt.
char buffer[17];
uint8_t l=0,n;
char *z=buffer;
utoa(zahl,buffer,2);
while(*z!=0){l++; z++;}//Bufferlänge l
for(n=l;n<sges;n++) USART_putc('0');
USART_puts(buffer);
}
Ein Byte binär senden:
//Ausgabe einer 8-Bit-Zahl binär(TSC)
void USART_putb(uint8_t a){
USART_putui_bin(a,8);
}
Eine erweiterte Bibliothek zur nicht-interrupt-gesteuerten seriellen Schnittstelle
finden sie hier:
Bibliothek