AVR C: Softwareentwicklung mit dem AVR Studio 5

From ConeleK Electronic Wiki
Jump to: navigation, search

Einleitung

Inhalt

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.


Installation des AVR Studio 5.1

Inhalt

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

Inhalt
Begrüßungsseite des AVR Studio

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).

Auswahl der Projektvorlage

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.

Auswahl des Mikrocontroller-Typs

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

Inhalt

Quelltext verfassen

Vorlage einer Hauptschleife im neuen Projekt

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

Inhalt

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

Meldung über unbekannte Firmware

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.


Upgrade-Dialog

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

Auswahl des Programmers

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

Tab zur Konfiguration der Fuses

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

Tab zur Konfiguration des Speichers

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

Tab zur Konfiguration des Speichers

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

Inhalt

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

Setzen eines Breakpoints zu Beginn der Main-Routine

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.

Tipps

Inhalt

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

Inhalt
  • AVR-Studio (Hauptseite) [8]
  • Download für AVR Studio 5.1.208 [9]
  • Mikrocontroller.net-Seite zum AVR-Studio [10]


Bezugsquellen

Inhalt
  • 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]