AVR-GCC-Tutorial_-_www_mikrocontroller_net.pdf

(614 KB) Pobierz
AVR-GCC-Tutorial - www.mikrocontroller.net
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
www.mikrocontroller.net
AVR-GCC-Tutorial
Inhaltsverzeichnis
[Verbergen]
1 Vorwort
2 Benötigte Werkzeuge
3 Was tun, wenn's nicht "klappt"?
4 Erzeugen von Maschinencode
5 Einführungsbeispiel
6 Exkurs: Makefiles
6.1 Controllertyp setzen
6.2 Quellcode-Dateien eintragen
6.3 Programmiergerät einstellen
6.4 Anwendung
6.5 Sonstige Einstellungen
6.5.1 Optimierungsgrad
6.5.2 Debug-Format
6.5.3 Assembler-Dateien
6.5.4 Taktfrequenz
6.6 Eingabedateien zur Simulation in AVR-Studio
7 Ganzzahlige (Integer) Datentypen
8 Bitfelder
9 Grundsätzlicher Programmaufbau eines µC-Programms
9.1 Sequentieller Programmablauf
9.2 Interruptgesteuerter Programmablauf
10 Allgemeiner Zugriff auf Register
10.1 I/O-Register
10.1.1 Lesen eines I/O-Registers
10.1.1.1 Lesen eines Bits
10.1.2 Schreiben eines I/O-Registers
10.1.2.1 Schreiben von Bits
10.1.3 Warten auf einen bestimmten Zustand
11 Zugriff auf Ports
11.1 Datenrichtung bestimmen
11.2 Vordefinierte Bitnummern für I/O-Register
11.3 Digitale Signale
11.4 Ausgänge
11.5 Eingänge (Wie kommen Signale in den µC)
11.5.1 Signalkopplung
11.5.2 Tasten und Schalter
11.5.2.1 Pull-Up Widerstände aktivieren
11.5.2.2 (Tasten-)Entprellung
11.6 Analog
11.7 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1, UBRR)
11.8 IO-Register als Parameter und Variablen
12 Der UART
12.1 Allgemeines zum UART
12.2 Die Hardware
12.3 UART initialisieren
12.4 Senden mit dem UART
12.4.1 Senden einzelner Zeichen
1 von 88
12.10.2007 23:35
AVR-GCC-Tutorial - www.mikrocontroller.net
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
12.4.2 Schreiben einer Zeichenkette (String)
12.4.3 Schreiben von Variableninhalten
12.5 Zeichen Empfangen
12.6 Software-UART
12.7 Handshaking
12.7.1 Hardwarehandshake (RTS/CTS)
12.7.2 Softwarehandshake (XON/XOFF)
13 Analoge Ein- und Ausgabe
13.1 ADC (Analog Digital Converter)
13.1.1 Der interne ADC im AVR
13.1.1.1 Die Register des ADC
13.1.1.2 Aktivieren des ADC
13.1.2 Analog-Digital-Wandlung ohne internen ADC
13.1.2.1 Messen eines Widerstandes
13.1.2.2 ADC über Komparator
13.2 DAC (Digital Analog Converter)
13.2.1 DAC über mehrere digitale Ausgänge
13.2.2 PWM (Pulsweitenmodulation)
14 LCD Ansteuerung
14.1 Das LCD und sein Controller
14.2 Anschluss an den Controller
14.3 Programmierung
15 Die Timer/Counter des AVR
15.1 Der Vorteiler (Prescaler)
15.2 8-Bit Timer/Counter
15.3 16-Bit Timer/Counter
15.3.1 Die PWM-Betriebsart
15.3.2 Vergleichswert-Überprüfung
15.3.3 Einfangen eines Eingangssignals (Input Capturing)
15.4 Gemeinsame Register
16 Warteschleifen (delay.h)
17 Sleep-Modes
18 Der Watchdog
18.1 Wie funktioniert nun der Watchdog?
18.2 Watchdog-Anwendungshinweise
19 Programmieren mit Interrupts
19.1 Anforderungen an Interrupt-Routinen
19.2 Interrupt-Quellen
19.3 Register
19.4 Allgemeines über die Interrupt-Abarbeitung
19.5 Interrupts mit dem AVR GCC Compiler (WinAVR)
19.5.1 ISR
19.5.2 Unterbrechbare Interruptroutinen
19.6 Datenaustausch mit Interrupt-Routinen
19.7 Interrupt-Routinen und Registerzugriffe
19.8 Was macht das Hauptprogramm?
20 Speicherzugriffe
20.1 RAM
20.2 Programmspeicher (Flash)
20.2.1 Byte lesen
20.2.2 Wort lesen
20.2.3 Floats und Structs lesen
20.2.4 Vereinfachung für Zeichenketten (Strings) im Flash
20.2.5 Flash in der Anwendung schreiben
20.2.6 Warum so kompliziert?
20.3 EEPROM
20.3.1 Bytes lesen/schreiben
20.3.2 Wort lesen/schreiben
20.3.3 Block lesen/schreiben
2 von 88
12.10.2007 23:35
AVR-GCC-Tutorial - www.mikrocontroller.net
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
20.3.4 EEPROM-Speicherabbild in .eep-Datei
20.3.5 EEPROM-Variable auf feste Adressen legen
20.3.6 Bekannte Probleme bei den EEPROM-Funktionen
21 Die Nutzung von printf
22 Assembler und Inline-Assembler
22.1 Inline-Assembler
22.2 Assembler-Dateien
22.3 Globale Variablen für Datenaustausch
22.3.1 Globale Variablen im Assemblerfile anlegen
22.3.2 Variablen größer als 1 Byte
23 Anhang
23.1 Besonderheiten bei der Anpassung bestehenden Quellcodes
23.1.1 Veraltete Funktionen zur Deklaration von Interrupt-Routinen
23.1.2 Veraltete Funktionen zum Portzugriff
23.1.3 Veraltete Funktionen zum Zugriff auf Bits in Registern
23.1.4 Selbstdefinierte (nicht-standardisierte) ganzzahlige Datentypen
23.2 Zusätzliche Funktionen im Makefile
23.2.1 Bibliotheken (Libraries/.a-Dateien) hinzufügen
23.2.2 Fuse-Bits
23.3 Externe Referenzspannung des internen Analog-Digital-Wandlers
24 TODO
Vorwort
Dieses Tutorial soll den Einstieg in die Programmierung von Atmel
AVR-Mikrocontrollern
in der Programmiersprache
C
mit dem freien (GPL, "kostenlosen") C-Compiler
AVR-GCC
erleichtern.
Vorausgesetzt werden Grundkenntnisse zum Programmieren in C. Diese Kenntnisse kann man sich online erarbeiten z.
B. mit dem OpenBook
C von A bis Z.
Nicht erforderlich sind Vorkenntnisse in der Programmierung von
Mikrocontrollern, weder in Assembler noch in einer anderen Sprache.
Die Erläuterungen und Beispiele beziehen sich auf die Versionen 3.4.5 des avr-gcc C-Compilers und 1.4.3 der avr-libc
Standardbibliothek, so wie sie in der Entwicklungsumgebung
WinAVR
20060125 enthalten sind. Die Unterschiede zu
älteren Versionen werden im Haupttext und Anhang zwar erläutert; Anfängern sei jedoch empfohlen, die aktuellen
Versionen zu nutzen.
In diesem Text wird häufig auf die Standardbibliothek avr-libc verwiesen, für die es eine
avr-libc
Online-Dokumentation
gibt. Bei WinAVR gehört die Dokumentation zum Lieferumfang und wird mitinstalliert.
Dieses Tutorial ist in PDF-Form erhältlich bei:
http://www.siwawi.arubi.uni-kl.de/avr_projects/AVR-GCC-Tutorial_-_www_mikrocontroller_net.pdf
Das ursprüngliche Tutorial stammt von Christian Schifferle, viele neue Abschnitte und aktuelle Anpassungen von
Martin Thomas. Viele der im Originaldokument verwendeten Funktionen sind in der aktuellen Versionen des avr-gcc
C-Compilers und der Laufzeitbibliothek avr-libc nicht mehr enthalten oder sollen nicht mehr genutzt werden. Dieses
Tutorial wurde an die neuen Funktionen/Methoden angepasst.
Benötigte Werkzeuge
Um eigene Programme für AVRs mittels avr-gcc/avr-libc zu erstellen und zu testen, wird folgende Hard- und Software
benötigt:
Platine oder Versuchsaufbau für die Aufnahme eines AVR Controllers, der vom avr-gcc Compiler unterstützt
wird (alle ATmegas und die meisten AT90, siehe Dokumentation der avr-libc für unterstützte Typen). Dieses
Testboard kann durchaus auch selbst gelötet oder auf einem Steckbrett aufgebaut werden. Einige
Registerbeschreibungen dieses Tutorials beziehen sich auf den inzwischen veralteten AT90S2313. Der weitaus
größte Teil des Textes ist aber für alle Controller der AVR-Familie gültig. Brauchbare Testplattform sind auch
3 von 88
12.10.2007 23:35
AVR-GCC-Tutorial - www.mikrocontroller.net
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
das
STK500
und der
AVR Butterfly
von Atmel.
mehr..
Der avr-gcc Compiler und die avr-libc. Kostenlos erhältlich für nahezu alle Plattformen und Betriebssysteme. Für
MS-Windows im Paket
WinAVR;
für Unix/Linux siehe auch Hinweise im Artikel
AVR-GCC.
Programmiersoftware und -hardware z.B. PonyProg (siehe auch:
Pony-Prog Tutorial)
oder
AVRDUDE
mit
STK200-Dongle
oder die von Atmel verfügbare Hard- und Software (STK500, Atmel AVRISP,
AVR-Studio).
Nicht unbedingt erforderlich, aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich:
AVR-Studio
(siehe Abschnitt
Exkurs: Makefiles).
Was tun, wenn's nicht "klappt"?
Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung
bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer-
oder Haustüren weiter" loswerden. Ansonsten:
C-Buch
(gibt's auch "gratis" online) lesen.
AVR Checkliste
Die
Dokumentation der avr-libc
lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently
Asked Questions
= Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
Den Artikel
AVR-GCC
in diesem Wiki lesen.
Das
GCC-Forum auf www.mikrocontroller.net
nach vergleichbaren Problemen absuchen.
Das avr-gcc-Forum bei
avrfreaks
nach vergleichbaren Problemen absuchen.
Das
Archiv der avr-gcc Mailing-Liste
nach vergleichbaren Problemen absuchen.
Nach Beispielcode suchen. Vor allem im
Projects-Bereich
von
AVRFREAKS
(anmelden).
Google oder yahoo befragen schadet nie.
Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen
(ganz und am Besten zweimal). Datenblätter sind von den
Atmel Webseiten
als pdf-Dateien verfügbar. Das
komplette Datenblatt (complete) und nicht die Kurzfassung (summary) verwenden.
Die Beispieleprogramme im
AVR-Tutorial
sind zwar in AVR-Assembler verfasst, Erläuterungen und
Vorgehensweise ist aber auch auf C-Programme übertragbar.
einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei möglichst viel Information
geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode oder besser ein
Testprojekt
mit allen notwendigen Dateien um das Problem nachzuvollziehen sowie genaue Fehlermeldungen
bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder
skizzieren (z.B. mit
Andys ASCII Circuit).
Siehe dazu auch:
"Wie man Fragen stellt".
Erzeugen von Maschinencode
Aus dem C-Quellcode erzeugt der avr-gcc Compiler (zusammen mit Hilfsprogrammen wie z.B. Präprozessor,
Assembler und Linker) Maschinencode für den AVR-Controller. Üblicherweise liegt dieser Code dann im Intel
Hex-Format vor ("Hex-Datei"). Die Programmiersoftware (z.B.
AVRDUDE,
PonyProg oder
AVRStudio/STK500-plugin) liest diese Datei ein und überträgt die enthaltene Information (den Maschinencode) in den
Speicher des Controllers. Im Prinzip sind also "nur" der avr-gcc-Compiler (und wenige Hilfsprogramme) mit den
"richtigen" Optionen aufzurufen um aus C-Code eine "Hex-Datei" zu erzeugen. Grundsätzlich stehen dazu zwei
verschiedene Ansätze zur Verfügung:
Die Verwendung einer Integrierten Entwicklungsumgebung (IDE), bei der alle Einstellungen z.B. in Dialogboxen
durchgeführt werden können. Unter Anderen kann AVRStudio ab Version 4.12 (kostenlos bei atmel.com)
zusammen mit WinAVR als integrierte Entwicklungsumgebung für den Compiler avr-gcc genutzt werden (dazu
müssen AVRStudio und WinAVR auf dem Rechner installiert sein). Weitere IDEs für den avr-gcc (ohne
Anspruch auf Vollständigkeit): AtmanAvr C (relativ günstig), KamAVR (kostenlos) VMLab (ab Version 3.12
ebenfalls kostenlos). Integrierte Entwicklungsumgebungen unterscheiden sich stark in Ihrer Bedienung und
stehen auch nicht für alle Plattformen zur Verfügung, auf denen der Compiler ausführbar ist (z.B. AVRStudio nur
für MS-Windows). Zur Anwendung des avr-gcc Compilers mit IDEs sei hier auf deren Dokumentation verwiesen.
Die Nutzung des Programms make mit passenden Makefiles. In den folgenden Abschnitten wird die Generierung
von Maschinencode für einen AVR ("hex-Datei") aus C-Quellcode ("c-Dateien") anhand der universellen und
plattformunabhängigen Vorgehensweise mittels make und Makefiles näher erläutert. Viele der darin
beschriebenen Optionen findet man auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio
(AVRStudio generiert ein makefile in einem Unterverzeichnis des Projektverzeichnisses).
4 von 88
12.10.2007 23:35
AVR-GCC-Tutorial - www.mikrocontroller.net
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
Beim Wechsel vom makefile-Ansatz nach WinAVR-Vorlage zu AVRStudio ist darauf zu achten, dass AVRStudio
(Stand: AVRStudio Version 4.13) bei einem neuen Projekt die Optimierungsoption (vgl. Abschnitt
Exkurs: Makefiles,
typisch: -Os) nicht einstellt und die mathematische Bibliothek der avr-libc (libm.a, Linker-Option -lm) nicht einbindet.
Beides ist Standard bei Verwendung von makefiles nach WinAVR-Vorlage und sollte daher auch im
Konfigurationsdialog des avr-gcc-Plugins von AVRStudio "manuell" eingestellt werden, um auch mit AVRStudio
kompakten Code zu erzeugen.
Einführungsbeispiel
Zum Einstieg ein kleines Beispiel, an dem die Nutzung des Compilers und der Hilfsprogramme (der sogenannten
Toolchain)
demonstriert wird. Detaillierte Erläuterungen folgen in den weiteren Abschnitten dieses Tutorials.
Das Programm soll auf einem AVR Mikrocontroller einige Ausgänge ein- und andere ausschalten. Das Beispiel ist für
einen ATmega16 programmiert (Datenblatt), kann aber sinngemäß für andere Controller der AVR-Familie modifiziert
werden.
Zunächst der Quellcode der Anwendung, der in einer Text-Datei mit dem Namen
main.c
abgespeichert wird.
/* Alle Zeichen zwischen Schrägstrich-Stern
und Stern-Schrägstrich sind lediglich Kommentare */
// Zeilenkommentare sind ebenfalls möglich
// alle auf die beiden Schrägstriche folgenden
// Zeichen einer Zeile sind Kommentar
#include <avr/io.h>
int
main
(void) {
DDRB = 0xff;
PORTB = 0x03;
while(1)
{
/* "leere" Schleife*/;
}
/* wird nie erreicht */
return
0;
}
// (1)
// (2)
// (3)
// (4)
// (5a)
// (5b)
// (5c)
// (6)
In der mit (1) markierten Zeile, wird eine sogenannte Header-Datei eingebunden. In io.h sind die Registernamen
definiert, die im späteren Verlauf genutzt werden.
Bei (2) beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion
main.
Die Anschlüsse eines AVR ("Beinchen") werden zu Blöcken zusammengefasst, einen solchen Block bezeichnet
man als Port. Beim ATmega16 hat jeder Port 8 Anschlüsse, bei kleineren AVRs können einem Port auch weniger
als 8 Anschlüsse zugeordnet sein. Da per Definition (Datenblatt) alle gesetzten Bits in einem Richtungsregister
den entsprechenden Anschluss auf Ausgang schalten, werden mit DDRB=0xff alle Anschlüsse des Ports B zu
Ausgängen.
(4) stellt die Werte der Ausgänge ein. Die den ersten beiden Bits des Ports zugeordnete Anschluss (PB0 und PB1)
werden 1, alle anderen Anschlüsse des Ports B (PB2-PB7) zu 0. Aktivierte Ausgänge (logisch 1 oder "high")
liegen auf Betriebsspannung (VCC, meist 5 Volt), nicht-aktivierte Ausgänge führen 0 Volt (GND,
Bezugspotential).
(5) ist die so genannte Hauptschleife (main-loop). Dies ist eine Programmschleife, welche kontinuierlich
wiederkehrende Befehle enthält. In diesem Beispiel ist sie leer. Der Controller durchläuft die Schleife immer
wieder, ohne das etwas passiert (außer das Strom verbraucht wird). Eine solche Schleife ist notwendig, da es auf
dem Controller kein Betriebssystem gibt, das nach Beendigung des Programmes die Kontrolle übernehmen
könnte. Wäre die Schleife nicht vorhanden, würde der Zustand des Controllers nach dem Programmende
undefiniert.
5 von 88
12.10.2007 23:35

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin