AVR UART. ELV Modul: ch=&marke=

Transkript

1 AVR UART 1. Einleitung In dieser Anleitung soll beispielhaft gezeigt werden, wie die serielle Kommunikation zwischen einem AVR Mikroprozessor und dem PC aufgebaut wird. Hierbei wird erst der einfache Fall behandelt, in dem nur Daten vom Mikroprozessor zum PC gesendet werden, um Messdaten zu erfassen. Der zweite Teil beschreibt anschließend, wie sich Befehle zum Prozessor senden lassen und per Interrupt verarbeitet werden können, um den zu steuernden Aufbau zu kontrollieren. 2. Hardware Diese Anleitung beschränkt sich auf die kleineren Prozessoren der AVR Familie vom Hersteller Atmel. Die unten verwendeten Bibliotheken wurden auf einem Atmega16 Prozessor getestet, welcher für viele Anwendungszwecke mehr als ausreichend ist. Die folgende Schaltung soll als Beispielaufbau dienen. Die Pegelwandlung auf den vom PC verwendeten seriellen Anschluss wird im Beispiel über einen MAX232 IC realisiert. Dies kann jedoch auch einfacher über einen UART zu USB Controller gebaut werden, da moderne PCs nur noch selten einen herausgeführten COM Port verfügen. Hier links zu Fertigbausteinen: ELV Modul: ch=&marke= FTDI Kabel: Eine Suche nach den Schlagworten UART TTL USB Converter sollte jedoch für jeden Anwendungsfall eine passende Fertiglösung bieten. Diese UART TTL zu USB Konverter erlauben eine einfache und wenig fehleranfällige Verbindung zwischen MCU und PC. Sie werden an den Pins PD0(RXD) und PD1(TXD) angeschlossen und ersetzen die Pegelwandlerschaltung des MAX232 ICs. 1

2 !!!Pinbelegung für Atmega16 im TQFP Gehäuse!!!!!!Für eigene Schaltung bitte selbst prüfen!!! Abbildung 1: Beispielschaltung Atmega16 (Pinbelegung für TQFP Gehäuse!) mit MAX232 Abbildung 2: RS232 Stecker Bei der Verbindung vom Stecker zum Pegelwandler müssen RX und TX vertauscht werden, d.h. PIN1 im Schaltplan auf PIN2 am Stecker, PIN2 im Schaltplan PIN3 und PIN 3 im Schaltplan auf PIN5. Die Verbleibenden Pins können offen gelassen werden (wenn keine Flusssteuerung gewünscht ist, Normalfall). 2

3 3. Software Um die UART Schnittstelle der MCU verwenden zu können, muss sie erst initialisiert werden. Dies wird durch Einstellen der verwendeten Baudrate (9600Baud sollte immer gehen) im Headerfile des Projekts und durch den Aufruf der Funktion void uart_init(void) vor der Verwendung erledigt. To Do: a. CPU Takt definieren (AVR Studio, Rechtsklick aufs Projekt, Edit Configuration Options, Frequency in Hz eintragen) b. Einfügen der Baudratenberechnung ins Headerfile #include <avr/io.h> #include <inttypes.h> #include <avr/interrupt.h> //USART DEFS #define BAUD 9600UL // Baudrate #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) c. Einfügen der Datei usart.c ins Projekt (.c Datei aus Quellcode unten erstellen) d. Aufrufen der Funktion uart_init(void); im Hauptprogramm e. Sollen auch Daten empfangen werden können, muss noch folgende ISR (Interrupt Service Routine) eingebaut werden (vor dem Hauptprogramm) und der Interrupt global eingeschalten werden mit der Funktion sei();. Sie liefert die empfangenen Werte als String in uart_string[]. #define uart_maxstrlen 10 // Definiere maximale Laenge für Empfang volatile uint8_t uart_str_complete=0; volatile uint8_t uart_str_count=0; volatile char uart_string[uart_maxstrlen+1]="x"; ISR(USART_RXC_vect) unsigned char buffer; buffer = UDR; if ( uart_str_complete==0 ) if (buffer!='\n' && buffer!='\r' && uart_str_count<uart_maxstrlen-1) uart_string[uart_str_count]=buffer; uart_str_count++; else uart_string[uart_str_count]='\0'; uart_str_count=0; uart_str_complete=1; Rücksetzen der Variable uart_str_complete in main(), wenn der String empfangen wurde. 3

4 Die Datei usart.c enthält folgende Funktionen die für die Projekte relevant sind: uart_init(); wird benötigt, um UART zu initialisieren uart_putc(); sendet einzelnes Zeichen an PC uart_puts(char* s); sendet String an PC bis Null erreicht wird Die folgenden Funktionen sollten besser über die Interrupt Lösung realisiert werden: uart_getc(); empfängt einzelnes Zeichen vom PC uart_gets(char* Buffer, uint8_t MaxLen); empfängt String Um den einfachen Fall zu betrachten, wird nun eine Terminal Verbindung aufgebaut. Da Windows Vista / 7 nicht mehr über das bekannte HyperTerminal mehr verfügen, wird empfohlen sich folgende Programme anzusehen. Termite: HTerm: Im hier gezeigten Beispiel wird das Terminal Programm Termite verwendet. 4

5 4. Verbindungsaufbau und Datenübertragung Diese kleine Demo soll zeigen, wie die oben gezeigten Funktionen in einem Aufbau funktionieren. Die folgende Abbildung zeigt schematisch den Aufbau ISP bzw. JTAG Versorgungsspannung (5V) Atmega16 TX RX RX TX ELV USB Konverter USB PC NICHT ÜBER USB VERSORGEN UND AUSLESEN GLEICHZEITIG Abbildung 3: Schematischer Aufbau und Testaufbau 5

6 Nun kann die Entwicklungsumgebung gestartet und das Testprojekt erstellt werden. In diesem Fall wird AVR Studio 4.18 SP1 verwendet und als Programmer der AVR Dragon. Ist AVR Studio gestartet, wird ein neues AVR GCC Projekt angelegt und die für das System entsprechenden Einstellungen für den Prozessor und Debugger festgelegt (Atmega16 und AVR Dragon). mit einem Klick auf Finish wird das Projekt erstellt. 8 Mhz eintragen und mit OK bestätigen. 6

7 Nun folgendes Testprogramm in die UART_ELV_MODUL.c Datei einfügen #include <avr/io.h> #include <inttypes.h> #include <avr/interrupt.h> #include <util/delay.h> #define F_CPU UL //USART DEFS #define BAUD 9600UL // Baudrate #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) #define uart_maxstrlen 25 // Definiere maximale Laenge für Empfang volatile uint8_t uart_str_complete=0; volatile uint8_t uart_str_count=0; volatile char uart_string[uart_maxstrlen+1]="test"; ISR(USART_RXC_vect) unsigned char buffer; buffer = UDR; if ( uart_str_complete==0 ) if (buffer!='\n' && buffer!='\r' && uart_str_count<uart_maxstrlen-1) uart_string[uart_str_count]=buffer; uart_str_count++; else uart_string[uart_str_count]='\0'; uart_str_count=0; uart_str_complete=1; uart_str_complete=0; void uart_init(void) UCSRB = (1<<RXEN) (1<<TXEN) (1<<RXCIE); // UART RX, TX und RX Interrupt einschalten UCSRC = (1<<URSEL) (1<<UCSZ1) (1<<UCSZ0); // Asynchron 8N1 UBRRH = UBRR_VAL >> 8; UBRRL = UBRR_VAL & 0xFF; int uart_putc(unsigned char c) while (!(UCSRA & (1<<UDRE))) UDR = c; return 0; 7

8 void uart_puts (char *s) while (*s) uart_putc(*s); s++; uint8_t uart_getc(void) while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar ; return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben void uart_gets( char* Buffer, uint8_t MaxLen ) uint8_t NextChar; uint8_t StringLen = 0; NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen // Sammle solange Zeichen, bis: // * entweder das String Ende Zeichen kam // * oder das aufnehmende Array voll ist while( NextChar!= '\n' && StringLen < MaxLen - 1 ) *Buffer++ = NextChar; StringLen++; NextChar = uart_getc(); *Buffer = '\0'; // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen int main (void) uart_init(); sei(); while(1) uart_puts(uart_string); uart_puts("\n"); _delay_ms(500); In dem oben angegebenen Programm wurden Teile des auf veröffentlichten Tutorials verwendet. 8

9 Im Anschluss kann das Projekt kompiliert und auf das Zielgerät (Atmega16) übertragen werden. Programmiermodus wählen und Signatur abgleichen. 9

10 Nun FUSES setzen. LOW FUSE auf 0xE4 setzen den HIGH FUSE auf default (nicht JTAG abschalten!). HEX Datei wählen aus dem Ordner Default des Projekt. ACHTUNG, wird nicht automatisch aus aktuellem Projekt gewählt!!! Flashen mit klicken auf Programm. 10

11 Nun kann AVR Studio geschlossen und das Terminal Programm Termite gestartet werden. Mit Settings nun Parameter einstellen Kann im Gerätemanager eingesehen werden Ist die Verbindung, korrekt sollte der Teststring ankommen. 11

12 Um den Interrupt zu testen, senden wir nun einen String, den der Prozessor wie im Programm definiert, wieder als Endlosschleife zurück sendet. HIER TEXT EINGEBEN und Senden! Zur Messwertübertragung weitere brauchbare Funktionen sind: itoa: atoi: dtostrf(float,int,int,char*) float -> string Viel Spaß bei den Projekten! Hilfe zum Thema: 12