AVR C: Softwareentwicklung mit der Eclipse IDE

Aus ConeleK-Wiki
Wechseln zu: Navigation, Suche

Einleitung

Inhalt
AVR Eclipse Debug-Perspektive mit laufendem simulavr und avr-gdb
Versuchsaufbau mit MC-AVR8

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:

  1. Ein C-Programm wird mit Eclipse erstellt und in den Mikrocontroller geladen.
    Zum Beweis blinkt eine an den Mikrocontroller angeschlossene LED
    .
  2. Ein Programm wird mittels Simulator (simulavr [4]) debugged.



Installation von Eclipse und dem Eclipse Plugin

Inhalt

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
Dialog Help > Install New Software...
  • 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.


Dialog Install Details...
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.


Dialog Add Repository...
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

Inhalt

Ä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

Inhalt

Die Hardware

Mikrocontroller Modul ATmega8 MC-AVR8 [1]


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.

Versuchsaufbau Mikrocontroller Modul ATmega8 MC-AVR8 --> Artikel

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.

Versuchsaufbau Mikrocontroller Modul ATmega8 MC-AVR8 --> Artikel

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

Inhalt

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

Inhalt
Auswahl Start Eclipse, Auswahl Workspace für AVR

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

Inhalt
Auswahl File > New > C Project

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

Eclipse AVR Dialog C Projekt

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

Eclipse-AVR Dialog Select Configurations

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

Eclipse AVR Dialog Project Properties Target Hardware

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:

  1. 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.
  2. 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.



Auswahl der MCU Type mit dem Button Load from MCU

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

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:

  1. Das Auswahlfeld Programmer Configuration ist leer (rot umrandet)
  2. 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


Eclipse AVR editieren der AVRDude Konfiguration

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


Eclipse AVR Dialog AVRDude Programmer mit den richtigen Einstellungen

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.



AVR Eclipse Dialog Select Configutations nach Einstellung der Konfiguration für den Programmer

Wir kommen nun wieder zurück in den Dialog C Project < Select Configurations und klicken dann auf Next


Target CPU auswählen

Eclipse AVR Einstellung Target HW Properties

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)

Inhalt
Projekt Ledblinkc_02 erstellt

Im Project Explorer erscheint nun das neu erstellte Projekt.

Projekt Source-File erstellen

Nun klicken wir im Project Explorer den Ordner Ledblink_02 an und wählen

File > New > Source File



C Source File erstellen

Benennung des C-Source-Files

Im Dialog New Source File wird der Namen für das neue Sourcefile vergeben, in diesem Fall Ledblink_02.c



Source Code ins Source-Fenster eingefügt

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.



Source Code ins Source-Fenster eingefügt


Build Configurations Debug auswählen

Nun wird die Build-Konfiguration ausgewählt:

Project > Build Configurations > Set Active > 1 Debug


Build ausführen

Build all ausführen

Nun wird der Build-Vorgang gestartet:

Project > Build All


Source Ausgabe des Build-Vorgangs im Fenster Console

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
Source Projekt-Fenster nach dem Build-Debug-Vorgang

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)

Inhalt


Build Configurations Release auswählen

Inhalt
Auswahl Build-Configuration Release

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

Build all ausführen

Nun wird der Build-Vorgang gestartet:

Project > Build All

Output Console Build Release

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.


Projekt Fenster nach Build Release

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


Projekt Fenster nach Build Release
Projekt Fenster nach Build Release

Der Inhalt der beiden Files sieht folgendermaßen aus:


Programm in den Mikrocontroller laden

Inhalt

AVRDude Einstellungen kontrollieren

Project Properties auswählen

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



Dialog Properties AVRDude Programmer Einstellungen

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

Inhalt
Project Properties auswählen

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


AVR Dude Upload Message-Box

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

Inhalt

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

Inhalt

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

Inhalt


simulavr konfigurieren

Start Konfiguration simulavr

Zunächst starten wir die Konfiguration von simulavr wie im Bild rechts gezeigt.

Alternativ:

Run > External Tools > External Tools Configurations...

Konfiguration simulavr Main

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



Konfiguration simulavr Reiter Common

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

Inhalt
Debug Konfiguration Start

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


Debug Konfiguration Main

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



Debug Konfiguration Reiter Main

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


Debug Konfiguration Reiter Connection

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

Inhalt
Debug Konfiguration Start

Zum Starten des Debuggen muss zunächst simulavr gestartet werden.

Symbol Start mit Werkzeugkiste > Pfeil > Maus links klick

Fenster nach dem Start von simulavr

Nun startet der Simulator, ein Fenster öffnet sich. Diese Fenster hat drei Sektionen:

  • Registers
  • IO Registers
  • SRAM

Alle Werte sind noch mit 0 belegt.


Ausgabe simulavr in Console Anfang

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.

AVR Eclipse Ausgabe simulavr in Console warten auf gdb Client

Wenn man im Consolen-Fenster runter scrollt, erscheint unten die Mitteilung, dass simulavr auf die Verbindung mit dem gdb client wartet.

Start avr-gdb in der Standard-Konfiguration

Der Debugger avr-gdb wird nun gestartet.

Käfersymbol Pfeil > Maus links klick > Ledblinkc_02 Debug Standard

alternativ

Run > Debug

alternativ

F11


Bestätigung der Umschaltung auf die Debug-Perspektive

Nun erscheint eine Message-Box, die fragt, ob wir auf die Debug-Perspektive umschalten wollen. Dies bestätigen wir mit

Yes > Maus links klick



Menü Auswahl Views Registers und Memory

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 AVR Eclipse views menue button.png 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.



Debug-Perspektive während des Debuggens


Display von simulavr während des Debuggens

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

Inhalt

ToDo


Siehe auch (Artikel in diesem Wiki)

Inhalt



Externe Links

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

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