AVR Eclipse

Aus der Mikrocontroller.net Artikelsammlung, mit Beiträgen verschiedener Autoren (siehe Versionsgeschichte)
Wechseln zu: Navigation, Suche

Dieser Artikel beschreibt erste Erfahrungen mit Eclipse und der AVR-Toolchain.


Allgemeines zu Eclipse

Eclipse ist eine IDE, die sich alleine nicht zur Programmierung von C/C++ eignet. Dafür gibt es dann das Eclipse-Plugin CDT (auch von ECLIPSE.ORG). Die CDT erweitert Eclipse mit der Möglichkeit, C/C++ zu programmieren. Das aber erstmal nur mit dem GCC. Um die Toolchain AVR-GCC (WINAVR) einzubinden, benötigt man noch ein weiteres Plugin (CDT AVRGCC oder auch CDT AVR Plugin). Es ist auch möglich, ohne die beiden letzt genannten Plugins zu arbeiten, dann sind die Einstellungen für den GCC an AVR-GCC anzupassen (unkomfortabler).

Allgemeines zu dem AVR Eclipse Plugin

Da dieser Artikel nicht immer auf dem neuesten Stand ist, bekommt man weitere Informationen auf der englischen AVR Eclipse Plugin WIKI Seite

Eclipse Plugin Tutorials

  • Kurzanleitung zur Installation des Plugins (englisch).

Installation unter Windows

Was wird benötigt?

Compiler

  • WINAVR AVR-GCC Compiler Toolchain, siehe auch Artikel WinAVR

IDE

Eclipse braucht eine JAVA Runtime Enviroment, falls diese noch nicht installiert ist muss das auch noch heruntergeladen werden

Am einfachsten geht es, wenn man die Version mit dem integrierten CDT-Plugin verwendet. Unter diesem Link die "Helios SR2" Eclipse IDE for C/C++ Developers downloaden. (Es kann Probleme mit der aktuellen Eclipse-Version (Indigo) und WinAVR geben Quelle)

Das zusätzliche AVR Plugin ist notwendig zum Einbinden des AVR-GCC. Kann hier heruntergeladen werden. Oder, besser, in einer installierten Eclipse Umgebung eingebunden werden.

Programmer / Debugger

Zum Programmieren und Debuggen kann man eingentlich jedes beliebige Programm verwenden. Zum Debuggen kommt unter anderem AVaRICE zum Einsatz, mit dem man auch programmieren kann (JTAG). Wahlweise ist auch AVRDUDE zum programmieren zu verwenden. Das kann man machen, wie man möchte. Beide Programme sind in WINAVR (siehe oben unter Compiler) enthalten.

Wie Installieren

WinAVR sollte auf dem System installiert sein. Siehe oben.

JAVA

Java Runtime installieren.

IDE

Eclipse ist in einem Zip Archiv, das an einen beliebigen Ort entpackt werden kann. Gestartet wird das Programm mit der Datei eclipse.exe. Meldet Eclipse beim Start einen Fehler, ist wahrscheinlich keine oder eine unpassende JAVA Runtime Enviroment installiert.

Plugin

Es gibt zwei Möglichkeiten, wobei die erste empfohlen wird:

Über Updatesite:
  • Eclipse starten. Zum Software Update Dialog gehen (Help > Install New Software ...)

Achtung der Link oben zur updatesite liefert nicht die neuste Version. Diese findet man auf der Downloadseite des Projekts als ZIP: https://sourceforge.net/projects/avr-eclipse/files/avr-eclipse%20stable%20release/

Direkt installieren:

Das Plugin ist ebenfalls eine ZIP-Datei die entpackt werden muss. Alle Dateien und Ordner im features Ordner müssen in den features Ordner von Eclipse kopiert werden. Alle Dateien und Ordner im Verzeichnis plugins müssen in den plugins Ordner von Eclipse kopiert werden.

Installation unter Linux

openSuSE

Eclipse läßt sich einfach via zypper oder yast installieren: 

zypper install eclipse

Seit openSUSE 11.4 muss man ein neues Repository hinzufügen: 

http://download.opensuse.org/repositories/CrossToolchain:/avr/openSUSE_12.1/

und dann 

zypper install avr-libc cross-avr-gcc

ausführen. Benutzt man noch 11.3, muss man avr-libc-1.7.0.5.1 aus den alten Repos installieren, da die neueste Version von cross-avr-gcc dort verbuggt ist (vllt. io.h vergessen?).

Gentoo

Eclipse-IDE

  • emerge eclipse-sdk -av

Den Rest per eclipse update oder von Hand:

Compiler

crossdev emergen:

  • emerge crossdev

Stabile Version der avr-toolchain inkl. g++ kompilieren:

  • USE="-nocxx" crossdev -s4 -S -t avr --ov-output /usr/local/portage

Es gibt Probleme mit crossdev und den ldscripts. Der Link wird nicht angelegt. Fix für 64Bit:

  • ln -s /usr/lib64/binutils/avr/2.20.1/ldscripts/ /usr/avr/lib/

Programmer

  • emerge uisp

Debian

Eclipse-IDE

Compiler

  • binutils-avr 2.15-3
  • gcc-avr 1:3.4.3-2
  • avr-libc 1:1.2.3-3

Debugger

  • simulavr 0.1.2.2-1
  • gdb-avr 6.3-2
  • ? avra 0.7-1

Programmer

Ubuntu 8.10 (Zum ersten)

Eclipse-IDE

Compiler

  • binutils-avr: 2.18-3
  • gcc-avr: 1:4.3.0-2
  • avr-libc: 1:1.6.2-1

Debugger

  • avr-gdb: 6.6; In den Repositories ist 6.4.90!
  • avarice: 2.7-2
  • simulavr: 0.1.2.2-6.1 (nicht getestet, sollte aber genauso funktionieren)

Programmer

Zusätzliche notwendige Programme/Libraries

  • gcc
  • binutils-avr
  • build-essential
  • ncurses-dev

Ubuntu (Zum zweiten)

AVR-Toolchain

Leider ist in den Repositories nur eine veraltete Version von avr-gdb (bzw. gdb-avr) enthalten. Diese Version hat bei mir zu Fehlern geführt. Deshalb wird die aktuelle Releaseversion 6.6 verwendet.

Schritt für Schritt

Als erstes werden die notwendigen Programme aus den Repositories installiert: 

sudo apt-get install gcc gcc-avr avr-libc avrdude binutils-avr avarice build-essential ncurses-dev

Ubuntu 6.10: 

sudo apt-get install gcc gcc-avr avr-libc avrdude binutils-avr avarice build-essential libncurses5-dev

Zusätzlich können auch noch folgende Packages interessant sein:

  • Simulavr: Ein Simulator für die AVR-Reihe
  • uisp: Alternativer Downloader
sudo apt-get install simulavr uisp

Jetzt kann man bereits das AVR-Target ansprechen, um z. B. die Fuses auszulesen: 

avarice -j /dev/ttyUSB0 -P atmega128 -r
  • -j: Gibt das Gerät an, mit dem das Target verbunden ist.
  • -P: Zielarchitektur
  • -r: Read Fuses

Dazu ist die Manpage von avarice zu empfehlen: 

man avarice

Als nächstes muss gdb-avr heruntergeladen und dann kompiliert werden: 

wget ftp://ftp.gnu.org/gnu/gdb/gdb-6.6.tar.bz2
tar jxf gdb-6.6.tar.bz2
cd gdb-6.6
./configure --target=avr --prefix=/usr/local/avr
make
sudo make install
cd ..
rm -rf gdb-6.6

Dies installiert die aktuelle Version von gdb-avr unter /usr/local/avr. Diesen Pfad könnte man zur PATH-Variable hinzufügen, dies ist allerdings nicht zwingend notwendig.

Unter Ubuntu 8.10 kommt es bei der Installation zu Problemen. Hier gibt es Abhilfe: http://www.mikrocontroller.net/topic/76404#1198507

Zitat:

Die Fehlermeldung lautet ja: 

avr-dis.c:xxx: error: format not a string literal and no format arguments

und Zeile xxx in dieser Datei lautet: 

sprintf (buf, xyz);

Wenn man das in 

strcpy(buf, xyz);

ändert, sollte es funktionieren.

Ubuntu 12.04LTS und 12.10 Die Default Eclipse Installation mit dem Paket Manager von Ubuntu funktioniert nicht. Das einfachste ist es die aktuelle Developer C/C++ Version von der Eclipse Webseite herunter zu laden. Dann es in deinem Heimatverzeichnis ( z.b: /home/superuser/) auspacken. Gehe in das Verzeichnis ../eclipse und rufe das Programm eclipse auf. Das Programm verlassen und es noch einmal aufrufen. Jetzt erst einmal die Update Funktion unter "help" aufrufen und anschliessend dann das AVR Plugin installieren. Dazu die Webseite des AVR Plugins aufrufen und der dortigen Beschreibung folgen. Ist das Plugin installiert Eclipse neu starten und anschliessend die Onlinehilfe aufrufen. Hier ist unter dem Punkt AVR sehr gut beschrieben wie Du dann die weitere Konfiguration machen must und wie das Plugin und die Arbeit mit Eclipse funktioniert.

Einrichten von Eclipse unter Windows

Beim ersten Start muss man einen Workspace angeben, dazu kann das vorgeschlagene Standardverzeichnis verwendet werden, wenn nur ein Benutzer diesen Workspace verwendet, ansonsten sollte man einen Ort auswählen, auf den alle Zugriff haben. Danach sollte das Bild so aussehen. Klicke auf Workbench.

EclipseStart.png

Einrichten von Eclipse unter Linux

Alternative 1

Das AVR-Eclipse Plugin kann über den Marketplace oder über die Update-Site http://avr-eclipse.sourceforge.net/updatesite/ installiert werden, (Help->Software Updates...), oder als download von der Projekteite (https://sourceforge.net/projects/avr-eclipse/files/) heruntergeladen und manuell installiert werden. Die neueste Version (aktuell 2.4.2) gibt es als aktuell nur als download von der Projektseite. Weitere Details dazu findet man auf der Projektseite (http://avr-eclipse.sourceforge.net/wiki/index.php/Plugin_Download)

Einstellungen

Jetzt müssen noch gewisse Einstellungen in Eclipse angepasst werden: Unter Window->Preferences->AVR->Paths: Wenn ein path im OS zu einem avr-gcc angelegt ist, findet das plugin den automatisch. Ansonsten muß man hier die Pfade zum Compiler, make, den avrlibc-headern, und AVRDude eintragen.

Unter Window->Preferences->AVR->AVRDude: Hier lassen sich globale (=projektübergreifende) Konfigurationen für AVRDude anlegen.

Projekteinstellungen

Jetzt kann ein neues C-Project angelegt werden, wobei als Projekttyp "AVR Cross-Target Project" ausgewählt werden muss.
Im "New Project Wizard" kann der MCU-Typ und die Quarzfrequenz eingestellt werden. Dies lässt sich später unter Projekt->Properties->AVR->Target Hardware ändern.

Unter Projekt->Properties->AVR->AVRDude werden die für das Projekt gültigen Parameter für AVRDude eingestellt.

Weitere Optionen sind in den Projekteinstellungen unter "C/C++ Build->Settings" zu finden. Hex-files werden nur erzeugt, wenn unter "General" die Häkchen dafür gesetzt werden.

Alternative 2

Dabei werden die Projekteinstellungen eines Standard-C-Projekts so verändert, dass die AVR-Toolchain verwendet wird.

Mein erster erfolgreicher Versuch lief mit einen "managed C Projekt". Ich hoffe in der folgenden Beschreibung fehlt kein Schritt:

  • File / New / Managed Make C Project
    • Project Name "test2" [Next]
    • Project Type "Executable (GNU)" [Next]
    • C/C++ Indexer "full ..." [Finish] (hab ich später geändert siehe unten)

Projekteinstellungen

  • File / New / SourceFile
    • [Browse] "test2" [OK]
    • Source File: "test2.c" [Finish]
  • Project / Properties
    • C/C++ Build / ToolSettings
      • GCC-C-Compiler
        • Command: gcc ändern auf avr-gcc -mmcu=atmega16 -c
        • Das -c ist wichtig, damit nur kompliert aber nicht gelinkt wird.
        • Directorys Eintrag /usr/avr/include einfügen
        • Debugging gewünschten Wert einstellen (z. B. -g)
      • GCC-C-Linker
        • Command: gcc auch ändern auf avr-gcc -mmcu=atmega16
        • Libraries: Library Search Path= /usr/avr
        • Miscellaneous: Linker Flags = -Wl,-Map,avr.map
      • GCC Assembler
        • Command: as ändern auf avr-as
    • C/C++ Build / Build Steps
      • Post-Build-Step
        • Command: avr-objcopy -j .text -j .data -O ihex test2 test2.hex
    • C/C++ Indexer
      • Available Indexers = CTags Indexer (declarations only)
      • Include Files: Index Include paths einschalten

später eingefügt:

  • Project / Properties
    • C/C++ Build / Build Steps
      • Pre-Build-Step
        • Command: uisp -dprog=dasa2 -dserial=/dev/ttyS0 -dpart=atmega16 --erase
  • Project / Properties
    • C/C++ Build / Build Steps
      • Post-Build-Step
        • Command: avr_upload
  • Project / Properties
    • C/C++ Build / Build Settings
      • Build Output
        • Artifact Name: avr_main

avr_upload ist eine kleine Batchdatei im Verzeichniss /usr/bin , die ich neu angelegt hab: 

#!/bin/sh
# .lst-Datei erzeugen (optional)
# avr-objdump -h -S avr_main > avr.lst
# Datei in Intel-hex erzeugen
avr-objcopy -j .text -j .data -O ihex avr_main avr.hex
# Intel-hex-Datei uploaden
#uisp -dprog=dasa2 -dserial=/dev/ttyS0 -dpart=atmega16 --upload if=avr.hex
# Intel-hex Datei uploaden und verifizieren.
uisp -dprog=dasa2 -dserial=/dev/ttyS0 -dpart=atmega16 --upload if=avr.hex --verify

Eclipse Plugin

Im Forum gibt es ein Plugin für Eclipse, das einen Großteil dieser Einstellungen bereits beinhaltet. Der Thread steht unter:

http://www.mikrocontroller.net/forum/read-2-229419.html#new

Das Plugin wird dort zum Download angeboten. Aber es ist sicher hilfreich die dortige Anleitung zu beachten.

http://www.mikrocontroller.net/attachment.php/285349/org.eclipse.cdt.avrgcc_1.0.16.zip

HINWEIS: Bitte die aktuelle Version benutzen. Folgende Warnung bezieht sich auf die älteren Versionen (vor Version 1.0.14). WARNUNG: Bei mir funktionierten Timer-Interrupts mit dem Plugin nicht (die jedoch tadellos mit der WinAVR Makefile funktionierten). Vielleicht habe ich nur eine Option übersehen, seid aber auf der Hut. Wenn ihr Unregelmäßigkeiten bei IRQs feststellt, versucht's erstmal ohne das Eclipse-Plugin (bevor ihr stundenlang an eurem Code und euch selbst zweifelt :-) ).

Projekt erstellen

NewProject.png

Wichtig ist, dass man AVR Cross Target Application auswählt

CreateProject.png

Beim nächsten Schritt kann man auswählen, was für Konfigurationen man will. In den meisten Fällen reicht es aus, wenn man nur Release auswählt.

SelectConfigurations.png

In diesem Schritt wählt man den Prozessor und die Taktfrequenz aus, wobei die Taktfrequenz in Hz angegeben werden muss

TargetHardwareProperties.png

Erster Test

Die jeweiligen Alternativen beziehen sich auf die oben genannten verschiedenen Möglichkeiten.

Aufbau

Die folgenden Angaben beziehen sich auf ein sehr einfaches Entwicklungsboard von Pollin, welches aber auch einfach nachgebaut werden kann. Den Schaltplan gibt's als PDF hier.

Programm eintippen

(oder einfach von hier kopieren) 

#include <avr/io.h>
  
#define running  1  

// Unterprogramm mit Zeitschleife fuer ATMega16 ohne Quarz
void delay_ms( unsigned int ms )
{
    unsigned int  i;
    unsigned int  j;
       
    for ( i = ms;  i;  i-- ) 
    {
        for ( j = 51;  j;  j-- )
        {
        }
    }    
}

int main( void )
{
    // PortD6 als Output konfigurieren
    DDRD |= _BV(PD6);

    // Hauptschleife des Programms
    while ( running )
    {
    	// LED einschalten, und dann warten
        PORTD |= _BV(PD6);
        delay_ms( 1000 ); 
        
    	// LED ausschalten, und dann warten
        PORTD &= ~_BV(PD6);
        delay_ms( 29000 );         
    }
}

Um dass Programm zu kompilieren muss links im Project Explorer der Projektordner angeklickt werden.

MakeTarget.png

Eine Konfiguration fügt man mit Add hinzu. In neuen Fenster gibt man als Target Name einen Namen ein. Der Name wird später unter anderem für den Dateinamen der HEX-Datei verwendet.

MakeTargetOptions.png

Die Einstellungen mit Create bestätigen und das andere Fenster mit Cancel schliessen. Ändert man nun eine Datei und speichert sie ab, wird das Projekt automatisch kompiliert. Das kann übrigens über Project --> Build Automatically geändert werden, da es bei grossen Projekten nachteilig ist, wenn der da die ganze Zeit kompiliert. Ob das ganze funktioniert hat kann man überprüfen, indem man auf Console klickt. Wenn das Kompilieren erfolgreich war, sollte die Ausgabe etwa so aussehen: 

**** Build of configuration Release for project AVRTest ****

make 
Building target: AVRTest.elf
Invoking: AVR C Linker
avr-gcc -Wl,-Map,AVRTest.map -mmcu=atmega8 -o"AVRTest.elf"  ./main.o   
Finished building target: AVRTest.elf
 
Invoking: AVR Create Extended Listing
avr-objdump -h -S AVRTest.elf  >"AVRTest.lss"
Finished building: AVRTest.lss
 
Create Flash image (ihex format)
avr-objcopy -R .eeprom -O ihex AVRTest.elf  "AVRTest.hex"
Finished building: AVRTest.hex
 
Create eeprom image (ihex format)
avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex AVRTest.elf  "AVRTest.eep"
Finished building: AVRTest.eep
 
Invoking: Print Size
avr-size --format=avr --mcu=atmega8 AVRTest.elf
AVR Memory Usage
----------------
Device: atmega8

Program:     108 bytes (1.3% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)


Finished building: sizedummy

Projekteinstellungen

Allgemein

Die Einstellungen können unter Project --> Properties --> C/C++ Build --> Settings vorgenommen werden. Auch hier muss man zuerst das Projekt im Project Explorer erstmal anklicken.

ProjectProperties.png

Prozessor / Taktfrequenz

Den Prozessor oder die Taktfrequenz kann man hier verändern Project --> Properties --> AVR --> Target Hardware

Häufige Fehler

Wenn man auf den Knopf Load from MCU drückt und dann die Fehlermeldung: "Could not understand the output from avrdude" angezeigt bekommt und die Auswahl der "MCU Type" Liste ausgegraut ist, dann liegt das daran dass man den avr-gcc auf Deutsch verwendet. (Bei der Ausgabe des Befehls "avr-gcc --target-help" wird im Text nach "Known MCU names:" gesucht, jedoch steht dort "Bekannte MCU-Namen:", das führt dazu dass die Controller nicht gefunden werden.)

Lösung:

Einen Ordner /usr/local/eclipse-toolchain erstellen.
Dort eine Datei "avr-gcc Anlegen mit Folgenden Inhalt:
#!/bin/bash
LANG=en-US /usr/bin/avr-gcc $*
und eine Datei "avr-g++ Anlegen mit Folgenden Inhalt:
#!/bin/bash
LANG=en-US /usr/bin/avr-g++ $*
Diese Dateien jeweils Ausführbar machen (chmod +x)
und unter eclipse → Window → Preferences → AVR → Paths → als AVR-GCC Path /usr/local/eclipse-toolchain auswählen.

Prozessor brennen

AVRDude

Den Prozessor kann man mit dem AVR Button in der Symbolleiste direkt aus Eclipse heraus mit AVRDude programmieren, dafür muss man aber gewisse Einstellungen vornehmen.

Programmierhardware auswählen

Project --> Properties --> AVR --> AVRDude Danach klickt man auf den Tab Programmer und dann auf New. In der Liste wählt man einen Programmer aus und nimmt gegebenen falls zusätzliche Einstellungen vor.

HEX-Datei auswählen

Project --> Properties --> AVR --> AVRDude Danach klickt man auf den Tab Flash/EEPROM. Eigentlich reicht es aus, from Build auszuwählen.

Fuse- / Lockbits

Zu den Fuse- bzw. Lockbits gibt es in den jeweiligen Tabs diverse Einstellmöglichkeiten.

Debugging

Debuggen funktioniert mit Eclipse entweder mit avarice oder simulavr, wobei ersteres zum OnDeviceDebugging dient und zweiteres einen Simulator darstellt. Zusätzlich ist avr-gdb notwendig, welches wie unter Installation unter Ubuntu beschrieben, installiert werden kann. Einen Link zu einer Anleitung für das Debuggen mit Eclipse unter Windows findet ihr unten bei den Links.

simulavr

simulavr -g -p 1212 -d atmega16 -P simulavr-disp

startet den Simulator.

avarice

avarice -j /dev/ttyS0 -P atmega128 :1212

startet einen Server, der auf Port 1212 lauscht und das OnDeviceDebugging übernimmt.

Eclipseeinstellungen

Unter Eclipse muss ein neues Debug-Target erzeugt werden, was in den Projekteinstellungen unter Run/Debug-Settings funktioniert. Es muss C/C++ application ausgewählt werden und folgende Einstellungen müssen geändert werden:

  • Debugger
    • gdbserver auswählen
    • GDB debugger: Pfad zu avr-gdb (/usr/local/avr/bin/avr-gdb)
    • verbose console mode einschalten
  • Connection
    • TCP, localhost, port 1212 (siehe simulavr/avarice-Aufruf).

Unter Debugger muss für die Verwendung des Simulators Command-Datei mit folgendem Inhalt angegeben und daher auch erstellt werden: 

file link.elf
targ rem :1212
load

link.elf ist die Datei, welche durch den Build erstellt wird. Dies muss daher angepasst werden.

Beim On Device Debugging muss keine Command-Datei angegeben werden.

Debugging mit Eclipse Kepler

Bei den neuen Eclipse-Versionen (Stand: Eclipse Kepler, CDT 8.2.1, AVR-Eclipse 2.4.1) hat sich vor allem in Sachen Hardware-Debugging einiges geändert. Mit dem oben beschriebenen Weg kann das Programm kompiliert und per AVRDude auf den Mikrocontroller heruntergeladen werden. Das Debuggen mit Avarice und avr-gdb funktioniert jedoch nicht. Die Debugging-Profile sind teilweise nicht mehr vorhanden oder deren Einstellungen sind stark abgeändert.

Um das Debugging auch mit neuen Versionen zu ermöglichen sind folgende Einstellungen nötig:

  • "GDB Hardware Debugging"-Profil anlegen (in Debug Configurations)
    • Reiter "Debugger"
      • GDB Command -> "avr-gdb"
      • Remote Target -> Haken bei "Use remote target", "Generic TCP/IP", Hostname "localhost", Portnr "1212"
    • Reiter "Startup"
      • Haken bei "Reset and Delay" und "Halt" löschen
      • Haken bei "Load image" und "Load symbols" setzen
      • Wenn halten bei Einsprung in main() gewünscht -> Haken bei "Set breakpoint at: main"
    • Reiter "Source"
      • "Default" löschen
      • Add -> "Project - Path Relative to Source Folders" -> Projekt wählen
      • Add -> "Program Relative File Path"
  • Projekteinstellungen (Rechtsklick auf Projekt -> "Properties")
    • Reiter "C/C++ Build -> AVR Compiler -> Optimization"
      • Optimization Level -> No Optimizations (-O0)
      • Haken bei "Pack structs", "Short enums", "Each function ...", "Each data item ..." löschen

TODO: Dieses Unterkapitel bitte Prüfen und ggf. editieren / in andere Kapitel einbringen

Debugging mit Eclipse Oxygen

Da sich gerade die Funktionalität und die Menus des Hardware-Debuggings mit jeder Eclipse-Version ändern, hier die Anleitung für die aktulle Version Oxygen (getestet mit: Eclipse Oxygen , CDT 9.4.2, AVR-Eclipse plugin 2.4.1, avr-gcc Version 7.0.2, avr-gdb Version 7.9 oder 8.1)

Hier sind jetzt folgende Einstellungen nötig:

  • "GDB Hardware Debugging"-Profil anlegen (in Debug Configurations)

Sollte GDB Hardware Debugging in der Debug Configurations nicht vorhanden sein, muß das zunächst installiert werden: Help -> Install New Software -> Work with : "Oxygen - http://download.eclipse.org/releases/oxygen". "C/C++ GDB Harware Debugging" findet man unter "Mobile and Device Development".

    • Reiter "Debugger"
      • GDB Command -> "avr-gdb" (oder voller Pfad, falls der von Eclipse nicht gefunden wird)
      • Remote Target -> Haken bei "Use remote target", "Generic TCP/IP", Hostname "localhost", Portnr "1212"
    • Reiter "Startup"
      • Haken bei "Reset and Delay" und "Halt" löschen
      • Haken bei "Load symbols" setzen, "use Project binary"
      • Wenn halten bei Einsprung in main() gewünscht -> "Set breakpoint at:" auswählen und "main" eintragen
    • Reiter "Source" : keine Änderungen notwendig
  • Projekteinstellungen (Rechtsklick auf Projekt -> "Properties")
    • C/C++ Build -> Settings -> AVR Compiler -> Debugging -> Debug Info Format: auf "stabs+" oder "Operation System default" setzen.

Sollte Eclipse in der Debug-Ansicht im Dissassembly-Fenster das Dissassembly nicht anzeigen können, dann liegt das sehr vermutlich an einem uralten Bug im GDB (der leider seit vielen Jahren nicht gefixt wird). Näheres dazu hier: https://sourceware.org/bugzilla/show_bug.cgi?id=13519

Wer will und kann kann, sollte sich einen GDB mit dem in Comment 13 gezeigten Patch selber bauen.

TODO: Dieses Unterkapitel bitte Prüfen und ggf. editieren / in andere Kapitel einbringen

Auslesen von IO-Registern

Wenn verbose console mode eingeschaltet ist, kann in diesem Konsolenfenster direkt mit avr-gdb kommuniziert werden. Dadurch können unter anderem die Register ausgelesen werden: 

p/x *(char *)Adresse

gibt den Wert der Adresse als char aus. 

p/t *(char *)Adresse

returniert den Binärwert.

Die Adresse setzt sich aus einer Startadresse und einem Offset zusammen, wobei diese sich im entsprechenden io-Header der Architektur befindet. Beispielweise setzt sich die Adresse für das UCSR0B-Register eines Atmega128 aus der Startadresse 0x800020 und dem Offset 0x0A zusammen.

Für oft verwendete Register empfiehlt es sich, diesen mittels 

set $name=(char *)Adresse

einen Namen zuzuweisen. Diese könnte man in einer Datei speichern und diese als command-Datei beim Debugger angeben, wodurch man sich diese händischen Eingaben spart und mittels 

p/x *$name

bzw. 

display *$name

zugegreifen kann.

AVR Studio

Hinweise zum Debuggen mit AVR Studio (Windows) in einem Eclipse-Projekt gibt Marcel K. in http://www.mikrocontroller.net/topic/152059#1428733

Links

Erste Schritte mit Eclipse

Anleitung zum Debuggen mit Eclipse unter Windows

3 Tuts für Eclipse mit AVRs

AVR-Eclipse falsche Autovervollständigung/ Syntaxprüfung korrigieren

Weiteres

Bei Problemen kann dieser Thread verwendet werden, in den ich, wann immer es sich bei mir ausgeht, schauen werde.

Jeder ist aufgerufen hier weiterzumachen, wenn er mehr weiss, oder es besser gestalten kann.

Falls beim Umstieg auf eine neue Eclipse-Version seltsame Fehler vom Eclipse-Syntaxcheck gemeldet werden, steht hier das Rezept, wie man das in den Griff bekommen kann: Merkwürdige Fehler mit avr-gcc mit Eclipse

Abgerufen von „https://www.mikrocontroller.net/index.php?title=AVR_Eclipse&oldid=101424“