AVR C: Softwareentwicklung mit der Eclipse IDE
Einleitung
Dieser Artikel gibt unsere persönlichen Erfahrungen mit der Einrichtung der Eclipse IDE [2] zur Entwicklung von C-Programmen für den AVR ATmega8 Mikrocontroller wieder. Die Installation erfolgte auf einem PC mit dem Linux Betriebssystem Kubuntu 11.10 [3].
Zum Testen wurde das Mikrocontroller Modul ATmega8 MC-AVR8 in einem Versuchsaufbau wie in diesem Artikel beschrieben, verwendet.
Zwei Ziele sollen erreicht werden:
- Ein C-Programm wird mit Eclipse erstellt und in den Mikrocontroller geladen.
Zum Beweis blinkt eine an den Mikrocontroller angeschlossene LED. - Ein Programm wird mittels Simulator (simulavr [4]) debugged.
Contents
- 1 Einleitung
- 2 Installation von Eclipse und dem Eclipse Plugin
- 3 Installation der AVR-Toochain
- 4 Vorbereitung für das erste AVR-Projekt
- 5 Eclipse AVR-Projekt durchführen
- 6 Projekt debuggen
- 7 Siehe auch (Artikel in diesem Wiki)
- 8 Externe Links
- 9 Bezugsquellen
Installation von Eclipse und dem Eclipse Plugin
Fast alle Programme wurden aus dem in Kubuntu enthaltenen Paketmangement installiert.
Folgende Programme müssen installiert werden, um eine vollständige IDE unter Eclipse zu erhalten (es wird jeweils die von uns verwendete Version genannt):
- Eclipse Indigo Version: 3.7.1
- Eclipse-CDT Version 8.0.0 [5]
- sun-java-6.jdk Version 6.26
- simulavr Version 0.1.2.2
- AVR Eclipse Plugin
- Das AVR Eclipse Plugin fügt einige Funktionalität zur Eclipse Plattform hinzu, welche die Entwicklung von embedded SW unterstützt:
- Auswahl der Target-CPU
- Erzeugung des .hex Files zum Upload in den AVR Mikrocontroller
- zusätzliche "views" für den gewählten Mikrocontroller
- Registers, ein Fenster mit der Darstellung der Register des Controller-Core
- AVR Device Explorer (funktioniert bei mir leider nicht)
- AVR Supported MCUs
- Memory, ein Fenster mit einem Memory-Dump (bei mir leider buggy)
- ein Fuse und Lock-Bit-Editor
- direkte Einbindung von avrdude, ein Programm, welches den Upload des / der .hex-Files mittels Programmer dient
- Einbindung verschiedener Open-Source Entwicklungstools für die AVR-SW-Entwicklung
- Das Plugin kann von der folgenden URL heruntergeladen, bzw. installiert werden. Wir haben es mit der ersten dort beschriebenen Methode, also über die Update Site durchgeführt.
- Gehen Sie zum Menüpunkt: Help > Install New Software...
- Es erscheint der Dialog rechts:
- Die URL http://avr-eclipse.sourceforge.net/updatesite wird in das Feld Work with: eingetragen. In die Spalte der Tabelle Name darunter alle Optionen auswählen und dann auf Next klicken.
- Nun erscheint der Dialog Install Details. Hier sollten die beiden Punkte AVR Eclipse Plugin und AVR Eclipse Plugin aufgeführt sein. Mit Next geht es weiter zum nächsten Dialog.
- Im Feld Name kann eine Name für das Plugin vergeben werden, wir haben avr-eclipse gewählt. Wenn nun auf Ok geklickt wird, startet die eigentliche Installation des Plugins.
Hinweis zur Java Version:
wir arbeiten mit der Java Version von SUN 6.26. Ob die Java Version java-6-openjdk auch fehlerfrei funktioniert, haben wir nicht getestet. Welche Java-Version aktiv ist, kann man folgendermaßen mit der Eingabe in eine Konsole feststellen:
ruediger@comp1lx:~$ update-alternatives --config java
There are 2 choices for the alternative java (providing /usr/bin/java).
Selection Path Priority Status
------------------------------------------------------------
0 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 auto mode
1 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 manual mode
* 2 /usr/lib/jvm/java-6-sun/jre/bin/java 63 manual mode
Press enter to keep the current choice[*], or type selection number:
Hinweis zur Entwicklung von C/C++ als PC-Anwendung:
Wenn der Wunsch besteht, mit Eclipse PC-Anwendungen in C oder C++ zu schreiben, müssen noch die dafür erforderlichen Tools installiert werden.
Die Installation der nötigen Pakete kann folgendermaßen durchgeführt werden:
sudo apt-get update
sudo apt-get install --install-suggests build-essential
Durch den Parameter --install-suggests werden noch alle zum Bau von C/C++ Anwendungen erforderlichen Programme installiert
Installation der AVR-Toochain
Ähnlich wie das eclipse-cdt Plugin enthält das eclipse-avr Plugin nicht die Toolchain zur Cross-Platform Entwicklung auf Basis der AVR-Mikrocontroller. Diese muss daher separat installiert werden. Wir haben alle Programme mit Hilfe des Ubuntu / Kubuntu Packetmanagements installiert
Folgende Programme sind hierzu erforderlich:
| Programmm | Version | Beschreibung |
| avr-gcc | 4.5.3 | der GCC-Cross-Compiler für den AVR-Mikrocontroller, C/C++ |
| binutils-avr | 2.20.1 | eine Sammlung von Tools, Assembler, Linker, und weitere Tools zur Manipulation von binären Files |
| avr-gdb | 7.2 | Debugger für AVR |
| avrdude | 5.10 | Software zur Ansteuerung und Datentransfer zum Target für eine Vielzahl von Programmern |
| simulavr | 0.1.2.2 | ein Simulator für einige Atmel Mikrocontroller |
Entweder verwendet man zu Installation einen Paketmanger mit GUI, z.B. Synaptic oä., oder installiert mit folgender Eingabe in eine Konsole alle Programme auf einmal:
sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc avrdude simulavr
Vorbereitung für das erste AVR-Projekt
Die Hardware
Da es sich hier um ein Embedded-Projekt handelt, benötigen wir eine Hardware mit einem AVR-Mikrocontroller. In diesen wird das erste Programm, welches weiter unten erstellt wird geladen. Um die ganze Entwicklungskette testen zu können, brauchen wir einen Programmer. In diesem Fall benutzen wir den Programmer AVRISPmkII. Gut ist es, wenn man genau weiß, das zumindest die Hardware schon funktioniert.
Wir haben für diese Anwendung unser eigenes, fertig aufgebautes und getestetes Mikrocontroller Modul ATmega8 MC-AVR8 verwendet. Dieses Modul hat schon einen Stecksockel, in den der Stecker des Programmiergerät passt. Ausführliche Informationen über dieses Modul gibt es [[Mikrocontroller_Modul_ATmega8_MC-AVR8 --> | hier]].
Das Mikrocontrollermodul dient als Basis für einen minimalen Versuchsaufbau, der zum Ziel hat eine LED blinken zu lassen, sozusagen ein embedded "hello world". Der ganze Versuchsaufbau ist in wenigen Minuten erledigt und man hat schon mal eine gute funktionierende HW-Basis. Der ganze Aufbau ist dem Artikel Mikrocontroller Modul ATmega8 MC-AVR8 beschrieben.
Wer kein fertiges Modul verwenden will, kann sich mit wenig Aufwand ein Mikrocontroller-Minimalsystem aufbauen. Der Aufbau diese Minimalsystems ist in dem Artikel beschrieben.
Wenn man ganz sicher gehen will, dass die HW funktioniert, können Sie die folgenden Anwendungen anschauen oder nachvollziehen:
In diesen Anwendungen werden schon einige Tools eingesetzt, die später auch in der Eclipse-IDE verwendet werden.
Das erste Programm
Um die ganze Entwicklungs-Kette einmal zu durchlaufen, wird ein möglichst einfaches aber garantiert funktionierendes Programm benötigt, welches später in den Editor von Eclipse eingeben oder hinein kopiert wird.
Der Sourcecode:
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 }
Eclipse AVR-Projekt durchführen
In diesem Kapitel wird nun die Durchführung eines minimalen AVR Projekts mit der Programmiersprache C beschrieben. Hierzu wird der Source-Code des obigen C-Programms verwendet. Es geht hier nun darum, die gesamte Toolchain zur Funktion zu bringen und auch zu verstehen. Daher wird ein minimales Programm verwendet, von dem wir sicher wissen, dass es funktioniert. Die Funktion des der Hardware, des Programms, und der Programmierung mittels Programmiergerät des Mikrocontrollers kann nachgewiesen werden, wenn man folgende Anwendungen mit dem hier beschriebenen C-Programm vorher durchführt:
Wenn im weiteren Verlauf des Eclipse Projekts irgend etwas nicht funktionieren sollte, wissen wir, dass wir genau hier in der Eclipse-IDE suchen müssen, um das Problem zu beheben.
Eclipse starten
Zunächst wird Eclipse gestartet. Es erscheint der splash screen von Eclipse Indigo und ein Dialog zur Auswahl des Workspace. Wenn es schon einen Workspace gibt, kann er aus dem Listenfeld ausgewählt werden. Wenn er noch nicht existiert, auf Browse klicken, im darauf sich öffnenden Dialog einen Pfad auswählen und Create Folder klicken und einen Namen für den neuen Workspace angeben.
Hier wurde der Workspace in /home/ruediger/ angelegt und heißt avr. Hier werden nun alle Programme gesammelt, die für den AVR-Mikrocontroller geschrieben werden. Eine Programmhierarchie wird von Eclipse nicht unterstützt, d.h. alle zukünftigen AVR-Programme werden gleichberechtigt auf der ersten Ebene im Workspace avr gespeichert.
Ein neues AVR-C Projekt anlegen
Jetzt kommt die Stunde der Wahrheit, das erste C-Projektchen mit Eclipse-AVR wird gestartet.
Um ein neues AVR-C Projekt zu starten geht man folgendermaßen vor:
Wählen Sie aus dem Menü von Eclipse: File > New > C Project
Es erscheint der Dialog rechts im Bild. Hier werden folgende Eingaben vorgenommen, bzw. Auswahlen getätigt:
| Label | Beschreibung / Auswahl |
| Project name | der Name des Projekts, in diesem Beispiel Ledblinc_02 |
| Use default location | anhaken |
| Project Type | AVR Cross Target Applikation > Empty Project |
| Toolchain | AVR-GCC Toolchain |
Der Dialog bietet bezüglich AVR zwei mögliche Projekteinstellungen:
| Label | Beschreibung / Auswahl |
| AVR Cross Target Application | C-Programme die in eine Ziel-CPU geladen werden |
| AVR Cross Target Static Library | C-Module, die in einer statischen Bibliothek verwendet werden |
Unser Programm soll in den Mikrocontroller geladen werden, also ist der 1. Punkt AVR Cross Target Application richtig
weiter geht es mit Next
Konfiguration auswählen
In diesem Dialog auswählen:
| Label | Auswahl | Beschreibung |
| Debug | true | Einstellungen, die sich während der Entwicklung zum Debuggen eignen ein .hex File ist normalerweise nicht vorhanden, Debug-Symbole im Code, der Code kann deutlich größer sein als bei Release |
| Release | true | Einstellungen für das endgültige Programm, .hex File zum hochladen in den Mikrocontroller, Code Optimierung beim Compilieren möglich, der ausführbare Code kann deutlich kleiner sein als bei Debug |
Man kann nun entweder direkt auf Next klicken, oder auf den Button Advanced Settings.... Wenn man auf Next klickt, werden spezielle Einstellungen für den Mikrocontroller und das Programmiergerät erst später vorgenommen. Dies kann jederzeit im Punkt
- File > Properties oder
- Rechtsklick auf das Projekt im Projektbrowser > Properties
nachgeholt werden.
Wir erledigen die Einstellungen sofort, daher geht es weiter mit dem Button Advanced Settings...
Target CPU von HW laden
Das rechte Bild zeigt den Dialog Properties for Ledblinc_02. In der linken Spalte wird zunächst der Punkt Target Hardware ausgewählt. Im rechten Teil des Dialogs sieht man nun die Felder bzw. Auswahlfelder:
| MCU Type | ATmega16 | Load from CPU |
| MCU Clock Frequency | 1000000 |
Dies sind die Standartwerte, wie sie von Eclipse-AVR vorgegeben werden. Nun gibt es hinsichtlich der Auswahl der Target-CPU zwei Möglichkeiten:
- Wenn, wie oben beschrieben, eine funktionierende HW, bestehend aus einem Mikrocontrollersystem und einem damit verbundenen Programmer, am PC angeschlossen sind, braucht man nur auf den Knopf Load from CPU klicken und in dem Feld MCU Type erscheint die richtige in der HW verbaute MCU.
- Wenn man noch keine HW hat, stellt man die gewünschten Parameter von Hand ein.
Wenn die Methode Load from CPU erfolgreich ist, weiss man, das die Kommunikation zwischen der Target-HW und dem Programmiergerät funktioniert.
Wir haben in unserem Beispiel, da funktionierende HW vorhanden, den 1. Weg gewählt. Die beiden LEDs im AVRISPmkII blinken kurz, und die richtige MCU erscheint im Feld:
| MCU Type | ATmega8 |
Wenn das trotz funktionierender HW nicht gelingt, liegt das in der Regel daran, dass die Einstellungen für den AVRDude nicht stimmen, oder das gar kein Programmer ausgewählt wurde.
AVRDUDE konfigurieren
Die Einstellungen für den Programmer werden im Dialog
Properties for Ledblinkc_02 > AVR > AVRDude > Reiter Programmer
getätigt. Im Bild rechts ist der Dialog so dargestellt, wie er nach dem Aktivieren erscheint. Hier fallen nun 2 Punkte auf:
- Das Auswahlfeld Programmer Configuration ist leer (rot umrandet)
- Der String im AVRDude comandline preview -pm16 (rot umrandet) passt nicht zum Mikrokontroller ATmega8
Daher müssen wir zunächst eine Programmer Configuration erstellen. Hierzu klicken wir auf den Button New... geklickt
Danach erscheint der Dialog rechts: Der Dialog ist so gezeigt, wie er nach Eingabe der richtigen Parameter aussieht. Die wesentlichen Einstellungen sind:
| Label | Parameter | Beschreibung |
| Configuration name | ATmega8_AVRISPmkII | der Name der Konfiguration |
| Description | Default AVRDude Programmer Configuration. Modify as required for your setup. | eine frei wählbare Beschreibung der Konfiguration |
| Programmer Hardware(-c) | Atmel AVR ISPmkII | der benutzte Programmer |
| Programmer details from [/etc/avrdude.conf:341] | id = "avrisp2"; desc = "Atmel AVR ISP mkII"; type = stk500v2; |
|
| Override default port (-P) | usb | der Programmer hat ein USP-Interface |
| /Reset Line | restore to previos state = true | |
| Vcc Line | restore to previos state = true | |
| Commandline Preview | avrdude -cavrisp2 -Pusb [...part specific options...] |
Danach Ok wählen
Der Dialog AVRDude mit den richtigen Einstellungen sieht nun aus wie im Bild rechts. Weitere Einstellungen werden zunächst mal nicht vorgenommen, wir arbeiten mit den Default-Einstellungen.
Wir kommen nun wieder zurück in den Dialog C Project < Select Configurations und klicken dann auf Next
Target CPU auswählen
Nun erscheint der Dialog rechts. Eigentlich wurden im Punkt Target CPU von HW laden schon alle Einstellungen vorgenommen, aber es hilft nichts, hier muss nochmal von Hand der richtige Mikrocontroller MCU Type ausgewählt werden. Die MCU Frequency (Hz) kann erst mal so bleiben, die kann später noch angepasst werden. Nun wird auf Finish geklickt und das Projekt wird von Eclipse angelegt.
Projekt compilieren (Debug)
Im Project Explorer erscheint nun das neu erstellte Projekt.
Nun klicken wir im Project Explorer den Ordner Ledblink_02 an und wählen
File > New > Source File
C Source File erstellen
Im Dialog New Source File wird der Namen für das neue Sourcefile vergeben, in diesem Fall Ledblink_02.c
Im Project Explorer nun auf den Eintrag Ledblinkc.c doppelklicken. Das leere Source-Fenster Ledblinkc.c öffnet sich. In diese wird der Code hinein kopiert oder eingegeben, dann speichern.
Build Configurations Debug auswählen
Nun wird die Build-Konfiguration ausgewählt:
Project > Build Configurations > Set Active > 1 Debug
Build ausführen
Nun wird der Build-Vorgang gestartet:
Project > Build All
Klicken Sie den Reiter Console im unteren Fenster von Eclipse an. Hier ist die Ausgabe des Build-Vorgangs zu sehen. Wenn es keine Fehlermeldungen gibt, kann man davon ausgehen, dass das Compilieren und Linken funktioniert hat. Zur Sicherheit kann man noch den Reiter Problems anklicken, hier sollten keine Fehler stehen, eventuell gibt es die eine oder andere Warnung.
Weiter unten ist die Ausgabe des Console Fensters wiedergegeben, um sie in Ruhe mit der Ausgabe der eigenen Versuche vergleichen zu können.
**** Build of configuration Debug for project Ledblinkc_02 **** make all Building file: ../Ledblinkc_02.c Invoking: AVR Compiler avr-gcc -Wall -g2 -gstabs -O0 -fpack-struct -fshort-enums -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=atmega8 -DF_CPU=1000000UL -MMD -MP -MF"Ledblinkc_02.d" -MT"Ledblinkc_02.d" -c -o"Ledblinkc_02.o" "../Ledblinkc_02.c" In file included from ../Ledblinkc_02.c:19:0: /usr/lib/gcc/avr/4.5.3/../../../avr/include/util/delay.h:95:3: warning: #warning "Compiler optimizations disabled; functions from <util/delay.h> won't work as designed" Finished building: ../Ledblinkc_02.c Building target: Ledblinkc_02.elf Invoking: AVR C Linker avr-gcc -Wl,-Map,Ledblinkc_02.map -mmcu=atmega8 -o"Ledblinkc_02.elf" ./Ledblinkc_02.o Finished building target: Ledblinkc_02.elf Invoking: AVR Create Extended Listing avr-objdump -h -S Ledblinkc_02.elf >"Ledblinkc_02.lss" Finished building: Ledblinkc_02.lss Invoking: Print Size avr-size --format=avr --mcu=atmega8 Ledblinkc_02.elf AVR Memory Usage ---------------- Device: atmega8 Program: 3130 bytes (38.2% Full) (.text + .data + .bootloader) Data: 8 bytes (0.8% Full) (.data + .bss + .noinit) Finished building: sizedummy
Im Project Explorer sind nun einige Dateien hinzugekommen. Diese sind mit den grünen Rechtecken gekennzeichnet. Wenn diese Projekt ein PC-Projekt wäre, könnten wir es nun debuggen oder ausführen. Da wir aber einen Cross-Compiler verwendet haben (avr-gcc), wird ausführbarer Code für die gewählte Target-CPU (ATmega8) erstellt (Ledblinkc_02.elf).
Leider ist auch dieser noch nicht direkt auf dem ATmega8 ausführbar, da dieser zum Laden des Flash ein File im Intel-Hex-Format benötigt. Diese wird bei den gewählten Projekteinstellungen aber erst erstellt, wenn der Build-Release Vorgang ausgeführt wird. Mit den bisher erstellten Files kann das Programm debugged werden, denn normalerweise wird kein Programm von Anfang an fehlerfrei erstellt.
Projekt compilieren (Release)
Build Configurations Release auswählen
Die Standard-Einstellungen in Eclipse-AVR sind normalerweise so eingestellt, dass der Upload des Programms in den Mikrocontroller sehr einfach ist. Um diesen Schritt durchzuführen, müssen wir eine Build-Configuration Release erstellen. Nur Release enthält die erforderlichen Dateien, die für die Programmierung des Mikrocontrollers erforderlich sind, Ledblinkc_02.eep, der Inhalt des EEPROM und Ledblinkc_02.hex, der Inhalt des Flash-Speichers im Intel-Hex-Format [6] enthält.
Um die Fuses und Lockbits brauchen wir uns zunächst nicht kümmern. Hier kommen die Standardwerte für die Fuses
- High-Byte: 0xD9 = 0b1101 1001
- Low-Byte: 0xE1 = 0b1110 0001
zum Einsatz. Damit ist zunächst mal ein sicherer Betrieb (safemode) des Mikrocontrollers gewährleistet. Die Fuses bieten einen weiten Raum für Einstellungen, einige können sogar den Prozessor unbrauchbar machen.
Auswahl der Build-Configuration:
Project > Build Configuration > Set Active > 2 Release
Build (Release) ausführen
Nun wird der Build-Vorgang gestartet:
Project > Build All
Als Ausgabe auf der Eclipse-Console erhalten wir das Bild rechts. Wenn es keine Fehlermeldungen gibt, kann man davon ausgehen, dass das Compilieren und Linken funktioniert hat. Zur Sicherheit kann man noch den Reiter Problems anklicken, hier sollten keine Fehler stehen, eventuell gibt es die eine oder andere Warnung.
Weiter unten ist die Ausgabe des Console Fensters wiedergegeben, um sie in Ruhe mit der Ausgabe der eigenen Versuche vergleichen zu können.
**** Build of configuration Release for project Ledblinkc_02 **** make all Building file: ../Ledblinkc_02.c Invoking: AVR Compiler avr-gcc -Wall -Os -fpack-struct -fshort-enums -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=atmega8 -DF_CPU=1000000UL -MMD -MP -MF"Ledblinkc_02.d" -MT"Ledblinkc_02.d" -c -o"Ledblinkc_02.o" "../Ledblinkc_02.c" Finished building: ../Ledblinkc_02.c Building target: Ledblinkc_02.elf Invoking: AVR C Linker avr-gcc -Wl,-Map,Ledblinkc_02.map -mmcu=atmega8 -o"Ledblinkc_02.elf" ./Ledblinkc_02.o Finished building target: Ledblinkc_02.elf Invoking: AVR Create Extended Listing avr-objdump -h -S Ledblinkc_02.elf >"Ledblinkc_02.lss" Finished building: Ledblinkc_02.lss Create Flash image (ihex format) avr-objcopy -R .eeprom -O ihex Ledblinkc_02.elf "Ledblinkc_02.hex" Finished building: Ledblinkc_02.hex Create eeprom image (ihex format) avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex Ledblinkc_02.elf "Ledblinkc_02.eep" Finished building: Ledblinkc_02.eep Invoking: Print Size avr-size --format=avr --mcu=atmega8 Ledblinkc_02.elf AVR Memory Usage ---------------- Device: atmega8 Program: 88 bytes (1.1% Full) (.text + .data + .bootloader) Data: 0 bytes (0.0% Full) (.data + .bss + .noinit) Finished building: sizedummy
Der ganze Programmcode ist nun auf 88 Bytes geschrumpft, gegenüber 3130 Bytes im Build-Debug-Modus.
Im Project Explorer ist nun der Ordner Release und in diesem sind einige Dateien hinzugekommen. Diese sind mit den grünen Rechtecken gekennzeichnet. Nun gibt es auch die Dateien, die mit AVRDude in den Mikrocontroller geladen werden können:
- Ledblinkc_02.hex das Flash-Image
- Ledblinkc_02.eep das Eeprom-Image
Der Inhalt der beiden Files sieht folgendermaßen aus:
Programm in den Mikrocontroller laden
AVRDude Einstellungen kontrollieren
Nun wird nochmal kontrolliert, ob die Einstellungen der Project Properties für Release richtig sind. Hierzu
- Project Explorer > Project Ledbinkc_02 > Maus links klick
- Project > Properties > Maus links klick
alternativ
- Project Explorer > Project Ledbinkc_02 > Maus rechts klick > Properties
alternativ
- Alt + Enter
Der Dialog rechts erscheint.
Auswahl:
- AVR > AVRDude > Programmer > Programmer configuration > ATmega_AVRISPmkII
Den Eintrag im Textfeld AVRDude command line preview kontrollieren:
- avrdude -pm8 -cavrisp2 -Pusb -Uflash:w:Ledblinkc_02.hex:a
Die restlichen Reiter des Properties Dialogs bleiben zunächst einmal unberücksichtigt, da folgende Einstellungen im Moment nicht geändert werden, also die Default-Werte verwendet werden für:
- EEPROM-Image
- Fuses
- Lockbits
- Advanced
- Others
Es schadet aber nicht, mal auf die Reiter zu klicken und sich die Inhalte anzuschauen. Gegeben Falls können auch mal Auswahlfelder angeklickt, oder Einträge geändert werden. Sobald ein Parameter geändert wird, ändert sich auch der String im Textfeld AVRDude command line preview. Man kommt in den Default-Zustand immer wieder zurück, wenn man die Schaltfläche Restore Defaults klickt.
Aber Achtung:
Beim Rücksetzen auf Default mit der Schaltfläche Restore Defaults werden alle Werte im Dialog zurückgesetzt, auch die Programmer-Konfiguration als solche. Man muss daher wieder die alte Programmer-Konfiguration wieder herstellen:
- AVR > AVRDude > Programmer > Programmer configuration > ATmega_AVRISPmkII
Mikrocontroller programmieren
Nun kann das Programm endgültig in den Flash-Speicher des Mikrocontrollers geladen werden:
- AVR > AVR Upload Project to Target Device > Maus links klick
alternativ
- Ctrl + ALT + U
Eine Message-Box erscheint und gibt Auskunft über der Verlauf des Uploads. Da das Programm mit 88 Bytes sehr klein ist, erscheint diese nur ganz kurz und verschwindet dann wieder.
In der Eclipse Console gibt AVRDude folgenden Text aus:
Launching /usr/bin/avrdude -pm8 -cavrisp2 -Pusb -Uflash:w:Ledblinkc_02.hex:a
Output:
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.00s
avrdude: Device signature = 0x1e9307
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "Ledblinkc_02.hex"
avrdude: input file Ledblinkc_02.hex auto detected as Intel Hex
avrdude: writing flash (88 bytes):
Writing | ################################################## | 100% 0.05s
avrdude: 88 bytes of flash written
avrdude: verifying flash memory against Ledblinkc_02.hex:
avrdude: load data flash data from input file Ledblinkc_02.hex:
avrdude: input file Ledblinkc_02.hex auto detected as Intel Hex
avrdude: input file Ledblinkc_02.hex contains 88 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.04s
avrdude: verifying ...
avrdude: 88 bytes of flash verified
avrdude done. Thank you.
avrdude finished
Nun blinkt die LED und das 1. Ziel ist erreicht :)
Mikrocontroller löschen
Wenn man den Mikrocontroller komplett wieder löschen möchte, Flash und EEPROM, gibt man in eine Konsole folgenden Befehl ein:
avrdude -p m8 -c avrispmkII -P usb -e
AVRDude gibt danach folgenden Text aus:
avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.00s avrdude: Device signature = 0x1e9307 avrdude: erasing chip avrdude: safemode: Fuses OK avrdude done. Thank you.
Die LED blinkt nicht mehr und der Mikrocontroller ist gelöscht.
Projekt debuggen
Einführung Debuggen
Leider funktionieren Programme in der Regel nicht auf Anhieb, selbst wenn das Compilieren, Assemblieren und Linken mit Erfolg verlaufen ist. Aber ist gibt ja noch die logischen Fehler. Nun geht es an die Fehlersuche, das Debuggen.
Bei einem Embedded-System ist dies schwieriger als bei einem Programm auf einem PC für den PC. Wir haben es bei einem Embedded - System in der Regel mit einem anderen Mikrocontroller zu tun, als im PC, in meinem Fall arbeitet im PC ein 64-bit AMD-Controller, während das oben beschriebene Minimalprogramm in einen Atmel ATMega8 Mikrocontroller geladen werden soll. OP-Code und Registersrucktur sind vollig unterschiedlich (ganz abgesehen von der Leistung).
Um das Programm zu erstellen, haben wir daher einen Cross-Compiler (avr-gcc) benutzt. Zum Debuggen müssen wir den speziellen Debugger (avr-gdb) verwenden. Leider ist es damit nicht getan, so ohne weiteres kann man mit dem avr-gdb kein Programm für / in einem Mikrocontroller debuggen, da der Code ja nicht auf dem PC, sondern auf dem Mikrocontroller läuft.
Grundsätzlich gibt es verschiedene Möglichkeiten ein Mikrocontroller-Programm zu debuggen:
- Programm mit speziellen Debug-Statements erweitern, Programm in den Mikrocontroller laden, Benutzung der Eingänge mit definierten Stimuli, Benutzung von Ausgängen und Beobachtung dieser, z.B. mit LEDs, Oszilloscope o.ä, Ausgabe von Debug-Strings über die serielle Schnittstelle.
- Ein Logicanalyer mit Trace-Speicher und Disassembler (sehr aufwendig, teuer, viele Leitungen nötig)
- Verwendung eines (echten) Incircuit-Emulator ICE für den Mikrocontroller. Hierbei wird der Mikrocontroller durch eine spezielle HW ersetzt, die über ein POD (ein spezieller Adapter) mit der Target-HW und einer Schnittstelle mit dem Entwicklugs-PC verbunden ist. In der Regel gibt es einen Trace-Speicher und Eingänge für Logik-Signale. Eine sehr teure, aber professionelle Lösung.
- Verwendung eines SW-Simulators, in diesem Fall simulavr als Debug-Server für avr-gdb. Eine 0 EUR Lösung, aber unter den Blinden ist der Eineugige König.
- Verwendung eines In-System-Debugger. Die spezielle HW, die für das Debuggen beim (echten) ICE in einem speziellen Gerät sitzt, ist (teilweise) im Ziel-Mikrocontroller integriert. Der Mikrocontroller kommuniziert über eine Schnittstelle (z.B. JTag) mit einem HW-Interface und dieses wieder mit dem Entwicklungs-PC. Dieses HW-Interface ist erheblich günstiger als ein echter ICE oder ein Logic-Analyser. Leider gibt es für den ATMega8 kein solches Interface, wohl aber für den ATMega88 (welcher auch in den MC-AVR8) passt. Es gibt eine Open-Source-SW, welche eine Vielzahl von In-System-Debugger ansteuern kann. Diese heißt AVaRICE.
Im weiteren Verlauf wird nun der Weg mit dem Software-Simulator simulavr und dem ATmega8 weiter beschrieben. Es ist keine ideale Lösung, aber für einige Mikrocontroller funktioniert es ganz gut und ist für Hobby und Lehrzwecke sicher zu verwenden. Auf AVaRICE wird zu einem späteren Zeitpunkt eingegangen.
Das Zusammenspiel von Simulavr/AVaRICE und Eclipse/AVR Plugin stellt eine Client-Server-Architektur dar. Simulavr/AVaRICE arbeiten als Server, während gdb als Client arbeitet. Der Client kann einen Service vom Server anfordern, der daraufhin diesen Service ausführt und das Ergebnis an den Client überträgt. Client und Server tauschen Daten über einen Socket aus. In dieser Anwendung arbeitet ein TCP/IP Socket. Dieser Socket hat eine IP-Adresse und einen Port. In unserem Fall ist die Adresse localhost = 127.0.0.1 und der frei gewählte Port-Adresse 4242 (als Standardadresse verwendet simulavr 1212). Wichtig ist, dass Client und Server auf die gleichen Adressen und Ports eingestellt sind.
Beim Start des Debuggens muss zunächst der Server (also simulavr bzw. AVaRICE) gestartet werden. Der Server wartet dann auf eine Antwort des Client gdb. Wenn auch gdb aktiv ist und der Socket aufgebaut ist, kann das eigentliche Debuggen beginnen. Im Fall von Eclipse / AVR geht dies dann sehr komfortabel über die GUI von Eclipse per Klicks auf Schaltflächen, oder die Tastatur (zum Großen Teil mit Hilfe der Funktionstasten). Die Debug-Ergebnise werden in Eclipse in sog. Views dargestellt. Einige davon sind speziell durch das Eclipse-AVR-Plugin in Eclipse integriert worden.
Aber bevor das so schön funktioniert, müssen noch einige Einstellungen in Eclipse durchgeführt werden.
Debuggen mit simulavr
simulavr konfigurieren
Zunächst starten wir die Konfiguration von simulavr wie im Bild rechts gezeigt.
Alternativ:
Run > External Tools > External Tools Configurations...
Nun öffnet sich ein Dialog wie im rechten Bild, allerdings noch ohne Einträge.
Im linken Fenster des Dialogs:
Program > Maus rechts klick > New > Maus links klick
Nun folgende Eingaben ausführen:
| Label | Konfiguration | Beschreibung |
| Name | simulavr atmega8 | Bezeichnung der Konfiguration, beliebiger String. So erscheint die Konfiguration in Menüs. |
| Main | Maus links klick | Reiter, Grundlegende Konfiguration |
| Location: | /usr/bin/simulavr | der Pfad zu simulavr |
| Working Directory: | ${workspace_loc} | Die Variable enthält den absoluten Pfad des Arbeitsverzeichnisses auf der Festplatte |
| Arguments: | --gdbserver --port 4242 --device atmega8 -P simulavr-disp | Software zur Ansteuerung und Datentransfer zum Target für eine Vielzahl von Programmern |
Die Bedeutung des Strings
--gdbserver --port 4242 --device atmega8 -P simulavr-disp
im Feld Arguments:
--gdbserver
- läuft als gdb-Server, Erklärung siehe Einführung Debuggen
--port 4242
- Port ist 4242
--device atmega8
- simulierter Mikrocontroller, hier ATMega8
-P simulavr-disp
- zeigt Register und Speicherinhalte in einem gesonderten Fenster an
Der Inhalt der weiteren Reiter Refresh, Build, Environment wird nicht verändert.
Im Reiter Common
| Label | Konfiguration | Beschreibung |
| Name | simulavr atmega8 | Bezeichnung der Konfiguration, beliebiger String. So erscheint die Konfiguration in Menüs. |
| Common | Maus links klick | Reiter für verschiedene Einstellungen |
| Save as | Local file | Default, als lokales File speichern |
| Display in favorites menu | angehakt | die Konfiguration erscheint im Auswahlmenü |
| Encoding | Default -inherited(UTF-8) | Default |
| Standard Input and Output | Allocate console(necessary for input) | Default |
| Launch in Background | angehakt | Default |
Danach zunächst einmal:
Close > Maus rechts klick
Die Konfiguration von simulavr ist damit erst einmal abgeschlossen.
Debuggen konfigurieren
Nun wird die Konfiguration für das Debuggen erstellt.
- Käfer-Symbol Pfeil > Debug Configurations... > Maus links klick
alternativ
- RUN > Debug Configurations... > Maus links klick
Zunächst wird eine neue Debug-Konfiguration erstellt. Im linken Fenster des Dialogs:
C/C++ Application > Maus rechts klick > New > Maus links klick
Der rechte Dialog erscheint mit teilweise noch nicht ausgefüllten Feldern. Wir erledigen nun folgende Eingaben, bis der Dialog so aussieht wie rechts.
Im Reiter Main
| Label | Konfiguration | Beschreibung |
| Name | Ledblinkc_02 Debug Standard | Bezeichnung der Konfiguration, beliebiger String. So erscheint die Debug-Konfiguration in den entsprechenden Menüs. |
| Main | Maus links klick | Reiterfür die Grundeinstellungen |
| C/C++ Application | Debug/Ledblinkc_02.elf | Dies ist das File, welches zum Debuggen verwendet wird |
| Project | Ledblinkc_02 | der Projektname |
| Build Configuration | Debug | Default, da wir debuggen wollen Debug wählen |
| Disable auto build | wahr | vor dem Aufruf des Debuggers wird nicht noch einmal der Build-Vorgang ausgeführt |
| Connect process input & output to terminal | angehakt | Default, Eingaben und Ausgaben über die Konsole |
Als nächstes kommt im selben Dialog der Reiter Debugger an die Reihe.
| Label | Konfiguration | Beschreibung |
| Name | Ledblinkc_02 Debug Standard | Bezeichnung der Konfiguration, beliebiger String. So erscheint die Debug-Konfiguration in den entsprechenden Menüs. |
| Main | Maus links klick | Reiterfür die Grundeinstellungen |
| C/C++ Application | Debug/Ledblinkc_02.elf | Dies ist das File, welches zum Debuggen verwendet wird |
| Project | Ledblinkc_02 | der Projektname |
| Build Configuration | Debug | Default, da wir debuggen wollen Debug wählen |
| Disable auto build | wahr | vor dem Aufruf des Debuggers wird nicht noch einmal der Build-Vorgang ausgeführt |
| Connect process input & output to terminal | angehakt | Default, Eingaben und Ausgaben über die Konsole |
Im selben Dialog wird nun der Unter-Reiter Connection bearbeitet:
| Label | Konfiguration | Beschreibung |
| Name | Ledblinkc_02 Debug Standard | Bezeichnung der Konfiguration, beliebiger String. So erscheint die Debug-Konfiguration in den entsprechenden Menüs. |
| Debugger | Maus links klick | Reiterfür die Verbindungseinstellungen |
| Debugger | gdbserver | Der Debugger arbeitet mit einem Server zusammen, in diesem Fall ist der Server simulavr |
| Stop on startup | angehakt + main | der Debugger stoppt nach dem Start am Anfang des main-Programms |
| Connection | Reiter | Einstellungen für die Socket-Verbindung |
| Type: | TCP | Art der Socket-Verbindung |
| Host name or IP adress: | localhost | der Name des Host-Computers oder seine IP-Adresse |
| Port number: | 4242 | eine gewählte Port-Nummer, diese muss mit der Port-Nummer des Servers simulavr übereinstimmen |
Damit ist die Konfiguration erst einmal abgeschlossen.
Debuggen mit avr-gdb/simulavr
Zum Starten des Debuggen muss zunächst simulavr gestartet werden.
Symbol Start mit Werkzeugkiste > Pfeil > Maus links klick
Nun startet der Simulator, ein Fenster öffnet sich. Diese Fenster hat drei Sektionen:
- Registers
- IO Registers
- SRAM
Alle Werte sind noch mit 0 belegt.
Simulavr produziert gleichzeitig eine Ausgabe in die Eclipse-Console und teilt mit, dass er einen ATMega8 Mikrocontroller simuliert. Außerdem werden die IO-Register und deren Adressen angezeigt.
Wenn man im Consolen-Fenster runter scrollt, erscheint unten die Mitteilung, dass simulavr auf die Verbindung mit dem gdb client wartet.
Der Debugger avr-gdb wird nun gestartet.
- Käfersymbol Pfeil > Maus links klick > Ledblinkc_02 Debug Standard
alternativ
- Run > Debug
alternativ
- F11
Nun erscheint eine Message-Box, die fragt, ob wir auf die Debug-Perspektive umschalten wollen. Dies bestätigen wir mit
- Yes > Maus links klick
Nun haben wir das Ziel erreicht, die Debug-Perspektive öffnet sich:
In diese Debug-Perspektive können weitere Views integriert werden, welche das Debuggen sehr erleichtern. Diese können mit dem Button 
ausgewählt werden, der sich unten links im Debug-View befindet. Bei Maus klick links öffnet sich ein Menü.
- Registers
- ein Fenster, welches den Inhalt der Prozessorregister wiedergibt. Änderungen werden vom AVR-Plugin in gelb unterlegt. Mit Maus rechts klick erscheint ein Menü, in dem die Eigenschaften der Darstellung verändert werden können.
- Memory
- ein Fenster, welches den Inhalt des Speichers wiedergibt. Änderungen werden mit Text in der Farbe Rot präsentiert. Der dargestellte Speicherbereich startet hier bei 0x800020. Dies ist der Speicherbereich für die IO-Register. Wenn man die Adresse eines Registers benötigt, kann man sie beim ATMega8 z.B. aus dem Datenblatt des Mikrocontrollers ablesen (Datenblatt ATMega8 Seite 280). Für die beiden IO-Register in dieser Anwendung:
- DDRB = 0x17 --> 0x800020 + 0x17 = 0x800037
- PORTB = 0x18 --> 0x800020 + 0x18 = 0x800037
- Diese beiden Adressen sind im Bild unten gekennzeichnet. DDRB ist schon zu 0x01 gesetzt. Das Format kann mit dem Reiter New Renderings geändert werden.
Simulavr selbst besitzt selbst ein Display, welches in 3 Sektionen die folgenden Speicherbereiche ausgibt:
| Speicherbereich | Beschreibung |
| Registers | die internen Register des Mikrocontroller |
| IO-Registers | der Speicherbereich der Register im IO-Bereich |
| SRAM | der RAM Speicher des Mikrokontroller |
Debuggen mit AVaRICE
ToDo
Siehe auch (Artikel in diesem Wiki)
Externe Links
- Datenblatt des ATmega8 [7]
- Kubuntu [8]
- Eclipse [9]
- Eclipse CDT (C/C++ Development Tooling) [10]
- The AVR Eclipse Plugin [11]
- Simulavr [12]
- Simulieren mit AVR-Gdb und simulavr [13]
- Simulavr: an AVR simulator [14]
- AVR Libc [15]
- AVaRICE [16]
- gcc: the GNU Compiler Collection [17]
- gdb: The GNU Project Debugger [18]
- binutils [19]
Bezugsquellen
- Mikrocontroller Modul ATmega8 MC-AVR8 [20]
- LED Modul 3 LEDs rot auswechselbar vertikal [21]
- 4mm Labor-Buchsen 2-fach [22]
- Steckplatine 640 Kontakte Profi Line GL10 [23]
- Steckplatine 100 Kontakte zur Spannungsversorgung [24]
- AVR ISP MKII In-System Programmer für Atmel AVR 8bit mit ISP-Schnittstelle [25]
- Labornetzteil / Labornetzgerät 0-15V 0-1A analog, linear geregelt [26]
