AVR C: Softwareentwicklung mit dem AVR Studio 5
Einleitung
In diesem Artikel beschreiben wir, wie Sie unter Windows eine Entwicklungsumgebung (IDE) für das Mikrocontroller-Modul MC-AVR8 einrichten. Die gängige IDE für Windows ist dabei das frei verfügbare AVR Studio [1]. Im Prinzip ist auch eine Entwicklung mit Eclipse möglich, wie wir sie für Linux beschrieben haben. Jedoch ist die Umgebung im AVR Studio so weit ausgefeilt und bequem einzurichten, dass wir diesem hier den Vorzug geben.
Die Hauptziele dieses Artikels sehen wie folgt aus:
- Wir möchten ein Programm erstellen, welches eine LED blinken lässt.
- Dieses Programm übertragen und testen wir auf den Microcontroller.
- Weiterhin wünschen wir uns, dass wir den Microcontroller auch innerhalb der IDE simulieren können.
Contents
Installation des AVR Studio 5.1
Obgleich bereits die Version 6 des AVR Studios zur Verfügung steht, scheint es laut Mikrocontroller.net Probleme mit der Speicheranalyse zu geben [2]. Aus diesem Grund kommt in diesem Tutorial das AVR Studio Version 5.1.208 zum Einsatz. Die Installationsdatei kann man unter folgendem Link herunterladen: [3].
Die Installation an sich sollte keine Probleme bereiten. In aller Regel wird als Teilschritt der AVR Jungo USB-Treiber installiert.
Projekt erstellen
Wenn wir das AVR Studio das erste Mal starten, werden wir vom Willkommensbildschirm begrüßt.
Um ein neues Projekt anzulegen, wählen wir für einen direkten Einstieg links oben den Link New Project....
Dasselbe erreicht man auch über File -> New -> Project... (Shortcut: Ctrl + Shift + N).
Im folgenden Schritt wählen wir die Projektvorlage aus, indem wir in der Baumansicht C/C++ und darauf in der Liste AVRGCC C Executable Project anklicken.
Im unteren Bereich wählen wir den Projektnamen zu LED blinkt sowie ein Verzeichnis (hier bspw. C:\s21\conelek\avr_studio\tutorial_project), unter welchem unser Projekt (ledblink) abgelegt wird.
Wir bestätigen mit OK.
Wir werden nun aufgefordert den Typ des Mikrocontrollers anzugeben. Da die Liste sehr lang ist, wählen wir zunächst die Device Family zu megaAVR, 8-bit und anschließend den Mikrocontroller mit dem Namen ATmega8.
Wir bestätigen mit OK und haben die Projekterstellung beendet.
Programm erstellen
Quelltext verfassen
Uns wird jetzt ein Programm mit einer leeren Hauptschleife als Vorlage angeboten. Wir möchten jedoch unser durchgängiges "Hello World"-Beispiel nutzen: ein Programm welches eine LED blinken lässt. Dieser Quelltext wird vollständig durch das folgende Listing ersetzt. Da es manchmal Probleme beim Kopieren aus dem Wiki gibt, können Sie den Sourcecode hier herunterladen.
1 /*******************************************************************************
2 *
3 * Dieses Programm dient dazu die Programmierung des
4 * CEK-Moduls MC-AVR8 und die ganze Toolchain von Eclipse-AVR zu testen.
5 *
6 * Eine Leuchtdiode, die mit dem PIN 10 des Moduls verbunden ist, blinkt.
7 *
8 * Autor: Ruediger Kluge
9 * Datum: 05.01.12
10 *
11 *******************************************************************************
12 */
13
14 #ifndef F_CPU
15 #define F_CPU 1000000UL /* Quarz mit 1.000 Mhz */
16 #endif
17
18 #include <avr/io.h>
19 #include <util/delay.h>
20 #include <stdint.h>
21 /*
22 * Hauptprogramm
23 *
24 * In einer Endlosschleife wird abwechselnd der PIN 0 von PORT B mit einer
25 * 1 (LED ausgeschaltet) und einer 0 (LED eingeschaltet) belegt.
26 *
27 * Dazwischen wartet der Mikrocontroller.
28 */
29
30 int main(void)
31 {
32 const double DELAY = 100; // Definition der Pause
33 DDRB = (1 << PB0); // Aktiviere PB0 von PORT B als Ausgang
34 PORTB = (1 << PB0); // LED an Pin 0 von Port B aus
35
36 while (1) // Schleife des Programms, endet nie
37 {
38 PORTB ^= (1 << PB0); // Port B / PIN 0 toggeln
39 _delay_ms(DELAY); // warten
40 }
41 }
Kompilieren des Quelltextes
Um eine Binärdatei aus dem Quelltext zu erstellen, müssen wir nun nichts weiter machen als das Kompilieren anzustoßen: Build -> Build Solution (Shortcut: F7).
Ist unser Code fehlerfrei, dann wird am Ende im Konsolenfenster (unterer Bildrand) als Zusammenfassung die folgende Ausgabe zu sehen sein.
[...] ========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========
Der Compiler stellt uns weiterhin einige nützlich Informationen zur Verfügung wie etwa den Speicherbedarf unseres neuen Programms:
[...] Device: atmega8 Program: 88 bytes (1.1% Full) (.text + .data + .bootloader) Data: 0 bytes (0.0% Full) (.data + .bss + .noinit) [...]
Programm auf den Mikrocontroller übertragen
Bis vor kurzem war es anscheinend noch nicht möglich den von uns verwendeten Programmer AVR ISP mkII [4] zusammen mit dem AVR Studio zu nutzen [5]. In diesem Fall - und falls die folgende Anleitung nicht funktioniert - ist es möglich die Hex-Datei, die beim Kompilieren entsteht, über das Programm avrdude [6] außerhalb des Studios zu übertragen. Dazu existieren auch eine ganze Reihe von Benutzeroberflächen wie etwa AVRdude GUI [sourceforge.net/projects/avrdudegui/] oder auch AVR8 Burn-O-Mat [7].
Zu unserer großen Freude scheint sich dies geändert zu haben, sodass nun der gesamte Entwicklungszyklus, den wir hier beschreiben, innerhalb des AVR Studios durchzuführen ist!
Vorbereitung
Bevor wir fortfahren können, ist es wichtig, dass nun der Mikrocontroller betriebsbereit ist, d.h.
- die Schaltung ist korrekt aufgebaut,
- der Chip wird mit Spannung versorgt,
- der AVR ISP mkII ist am USB-Anschluss angeschlossen und
- mit dem Controller über die 6-polige Programmierschnittstelle verbunden.
Treiber für das Programmiergerät herunterladen
Um unser Programm zu übertragen, wählen wir Tools -> AVR Programming. Beim ersten Aufruf wird dem Studio möglicherweise auffallen, dass es keinen passenden Treiber für unseren Programmer besitzt und bietet daher an, diesen nachzuladen.
Wir bestätigen mit OK.
Es erscheint ein Fenster mit Informationen über den Programmer. Wir wählen die Schaltfläche Upgrade' neben dem AVR ISP mkII. Nachdem die Installation fertiggestellt ist, aktualisieren wir mit Refresh und neben dem Gerätenamen erscheint die Anzeige Up to date.
Den Dialog verlassen wir über OK.
=== Programmiergerät auswählen
Im folgenden Dialog können wir alles erreichen, was mit dem Aufspielen und Löschen von Programmen zu tun hat. Zunächst müssen wir jedoch den korrekten Programmer einstellen: Dazu wählen wir wie dargestellt als Tool den 'AVRISP mkII, als Device den ATmega8 und das Interface ISP.
Nach Betätigung von Apply werden im Hauptteil des Dialogs die Einstellmöglichkeiten und Informationen über den Programmer und das Device dargestellt.
Fuses kontrollieren
Der folgende Vorgang ist einmalig. Zunächst müssen wir die Grundeinstellungen überprüfen bzw. setzen. Die "Systemkonfiguration" des ATmega8 wird durch sogenannte [Fuses_ATmega8 | Fuses] bewerkstelligt. Wir navigieren in den Registern links zum Tab Fuses
Wir achten darauf, dass die folgende Konfiguration eingetragen ist:
- High: 0xD9
- Low: 0xE1
und drücken Program. Die Statusausgabe bestätigt uns den korrekten Ablauf des Brennvorgangs.
Programm übertragen
Nun sind wir tatsächlich in der Lage, unser Programm auf den Mikrocontroller zu übertragen. Dazu navigieren wir links zum Tab Memories und tragen im Eingabefeld Flash den Dateipfad zur Hex-Datei unseres Programms ein. Das Feld EEPROM können wir leer lassen.
Wie bereits bei den Fuses bewirkt Program, dass das Flash-Image auf den Controller geschrieben wird.
Nun blinkt die LED (hoffentlich :-)).
Speicher löschen
Im selben Tab können wir auch den Speicher des Mikrocontrollers löschen.
Dazu ist nur ein Klick auf die Schaltfläche Erase now nötig.
Simulation mit AVR Simulator
Natürlich möchte man nicht immer, wenn man eine kleine Änderung durchgeführt hat oder auf der Suche nach einem Fehler ist, den gesamten Entwicklungszyklus durchlaufen und das Programm auf dem Mikrocontroller brennen.
Daher bietet das AVR Studio auch die Möglichkeit einer Simulation in Form des AVR Simulators an.
Wir beschreiben in diesem Abschnitt, wie man die grundlegenden Tätigkeiten mit diesem Tool durchführt.
Breakpoint setzen
Wir möchten also gerne eine bestimmte Stelle im Code näher betrachten. Zu diesem Zweck können wir bei fast jedem Statement einen sogenannten Breakpoint setzen, an welchem der Debugger anhalten wird, während das Programm läuft.
Einen Breakpoint setzt man an bequemsten, indem man links neben die betreffende Codezeile klickt. Eine Alternative ist die Erstellung über das Kontextmenü: Rechtsklick -> Breakpoint -> Insert Breakpoint Es erscheint ein kleiner Kreis, der den Breakpoint symbolisiert.
Der Debugger wird nun in dieser Zeile oder der nächsten geeigneten anhalten.
Debugging starten und kontrollieren
Wenn wir alle gewünschten Breakpoints gesetzt haben, dann können wir das Debugging beginnen, indem wir wie folgt wählen: Debug -> Start Debug and Break (Shortcut: Alt + F5). Sobald der Debugger anhält, können wir in kleinen Schritten vorangehen. Dazu gibt es die folgenden Befehle:
- Step Into (Shortcut: F11): Falls das nächste Statement eine Funktion ist, betrete diese.
- Step Over (Shortcut: F10): Gehe zur nächsten Zeile (überspringe ggf. den Funktionsaufruf)
- Step Out (Shortcut: Shift + F11): Lasse die aktuelle Funktion bis zum Ende durchlaufen.
Wir können das Debugging mit dem Shortcut Ctrl + Shift + F5 stoppen.
Speicher analysieren
Während des Debuggens werden am rechten Rand Variablenbelegungen angezeigt, die vom aktuellen Code aus sichtbar sind. Möchten wir uns ansehen, was mit dem Ausgang für unsere Leuchtdiode passiert, können dazu den Register-Knoten aufklappen und zum Register R24 scrollen. Beim ersten Durchlauf wird der Wert auf 1 gesetzt und beim nächsten Durchlauf auf 0.
- Wechselnde Werte im Register R24
Register R24 ist gesetzt
Register R24 ist nicht gesetzt
Tipps
Syntaxvervollständigung
Das AVR Studio besitzt eine sehr gute Syntaxvervollständigung. Hat man begonnen ein Symbol einzugeben (bspw. #endi), dann kann man sich mit Ctrl + Space Vorschläge für passende Symbole anzeigen lassen, die mit dem Getippten beginnen (hier also wahrscheinlich #endif) und diese mit Return/Enter annehmen.
Code von der Simulation ausschließen
Wir haben die Erfahrung gemacht, dass sich der AVR Simulator gerne an delay-Funktionen verschluckt und bspw. an der Funktion __builtin_avr_delay_cycles(__ticks_dc); hängen bleibt. Hier kann man beispielsweise den Aufruf von _delay_ms(DELAY); (siehe oben) mit Präprozessor-Direktiven umgeben und ihn so während der Simulation deaktivieren:
#ifndef SIMULATOR
_delay_ms(DELAY); // warten
#endif
Natürlich muss man hierfür zuvor irgendwo ein
#define SIMULATOR
im Quelltext unterbringen und dieses manuell entfernen, wenn man dann doch wieder für die Hardware compiliert.
Externe Links
- AVR-Studio (Hauptseite) [8]
- Download für AVR Studio 5.1.208 [9]
- Mikrocontroller.net-Seite zum AVR-Studio [10]
Bezugsquellen
- Mikrocontroller Modul ATmega8 MC-AVR8 [11]
- LED Modul 3 LEDs rot auswechselbar vertikal [12]
- 4mm Labor-Buchsen 2-fach [13]
- Steckplatine 640 Kontakte Profi Line GL10 [14]
- Steckplatine 100 Kontakte zur Spannungsversorgung [15]
- AVR ISP MKII In-System Programmer für Atmel AVR 8bit mit ISP-Schnittstelle [16]
- Labornetzteil / Labornetzgerät 0-15V 0-1A analog, linear geregelt [17]
