Teil 3: Remote Debugging

Im dritten Teil beschreibe ich anhand des "Hello World" Beispiels aus Teil 2 , wie man mit Eclipse ein Project vom Host PC auf dem Raspberry Pi debuggt.

Übersicht

1. Beispielprojekt
2. Eclipse Remote - Verbindung
3. Eclipse Cross Debugger

1. Beispielprojekt

Im ersten Schritt erweitern wir das beispiel Projekt um ein par Zeilen Code, welche durch eine for Schleife eine zusätzliche Ausgabe generiert. Diese können wir dann schrittweise beim Debuggen betrachten.

1.1  Eclipse starten und das Projekt aus Teil 2 öffnen

1.2. Code erweitern

2. Eclipse Remote - Verbindung 

Im zweiten Schritt richten wie eine Remote - Verbindung von Eclipse zum Raspberry Pi ein. Im  Teil 2 hatte ich zwar beschrieben, wie mittels scp das fertige Binary auf das Raspberry Pi kopiert werden kann, für das Debuggen ist dies aber sehr umständlich. Daher nutze ich jetzt die Möglichkeiten von Eclipse, das Binary automatisch auf das Raspberry Pi zu kopieren und anschließend die Debug - Sitzung zu starten. Zusätzlich wird dazu ein Zugriff auf das Filesystem und eine Terminal - Verbindung eingerichtet.

2.1. Remote System View in Eclipse anzeigen

Zuerst müssen wir den entsprechenden View in Eclipse anzeigen, dazu unter Window -> Other auswählen: 

 Anschließend aus der Gruppe Remote Systems den Eintrag Remote Systems auswählen und mit OK bestätigen.

 2.2. Remote Connection einrichten

Nachdem der Remote System View aktiviert wurde (ich habe diesen auf die linke Seite, neben den Projekt Explorer verschoben), kann eine neue Verbindung eingerichtet werden.

Dazu mit der Rechten Maustaste in den View klicken und New Connection wählen:

Als Type wird unter General -> Linux ausgewählt:

Jetzt muss die Verbindung entsprechend des eigenem Raspberry Pis eingerichtet werden:

• Host name: Hostname oder IP Adresse des Raspberry Pis
• Connection name: frei wählbarer, aber einmaliger Name für diese Verbindung
• Description: (optional) Beschreibung der Verbindung

Mit Klick auf Next geht es zur nächsten Seite.

Hier wählen wir ssh.files und anschließend Next:

Hier wählen wir processes.shell.linux und anschließend Next:

 Hier wählen wir ssh.shells und anschließend Next:

Auf der letzten Seite wählen wir ssh.terminals und zum Schluss Finish:

2.3. Remote Connection herstellen

Wenn die Remote Verbindung korrekt eingerichtet wurde, erscheint im Remote System View der entsprechende Eintrag mit dem Connection name (bei mir raspbian).

Jetzt können wir die Verbindung zum Raspberry Pi herstellen. Dazu mit der rechten Maustaste auf den Connection name klicken und Connect auswählen:

Anschließend müssen wir den Login des Raspberry Pis eintragen. 

[Optional] Die beiden Hacken bei Save user ID und Save password setzten, damit muss der Login nicht jedesmal eingetragen werden. 

2.4. Zugriff auf das Filesystem und eine Terminal - Verbindung eingerichtet.

Nach erfolgreichen Login kann im Remote Systems View unter Root auf das Filesystem des Raspberry Pis zugeriffen werden. Unter My Home hat man Zugriff auf das Homeverzeichnis des angemeldeten Nutzters (siehe Login User ID):

Durch Klick mit der Rechten Maus auf Ssh Terminals und Launch Terminal,...

...kann direkt aus Eclipse heraus auf die Console des Raspberry Pis zugreifen. Eine zusätzliche ssh Verbindung ist so nicht notwendig.

3. Eclipse Cross Debugger

Im ersten Schritt haben wir das Beispielprojekt um ein par Codezeilen zum debuggen ergänzt, im zweiten Schritt wurde die Remote Verbindung zum Raspberry Pi eingerichtet. Im dritten Schritt richten wir die Debug Konfiguration für das Eclipse Projekt ein und starten anschließend die Debug Sitzung. Dabei setzten wir in der for Schleife einen Breakpoint, an dem die Ausführung unterbrochen wird und betrachten die schrittweise Ausgabe unseres Programms auf der Konsole.

3.1 . Debugger Konfiguration

In der Eclipse Menü Leiste wählen wir das Debug Sysmbol und anschließend Debug Configurations:

Da wir den Code nicht auf dem Host, sondern auf dem Target ausführen wollen, müssen wir eine neue Konfiguration unter C/C++ Remote Application erstellen:

Die Einstellungen werden entsprechend folgender Abbildung vorgenommen:

Anschließend wird der Tab Debugger/Main der GDB debugger unserer Toolchain aus Teil 1 eingetragen: arm-linux-gnueabihf-gdb

Im Tab Debugger/ Gdbserver Settings werden folgende Einstellungen eingetragen:

• Gdbserver path: gdbserver
• Port number: 2345  (muss auf Host und Target frei sein)

Mit Klick auf Debug können wir die Debug - Sitzung starten.

3.2. Debugging Starten

Nach dem der Debugger gestartet wurde, will Eclipse in die Debug Perspektive wechseln, die entsprechende Nachfrage kann man mit Yes bestätigen und den Haken bei Remember my decision nach belieben setzten.

Anschließend wechselt Eclipse in die besagte Debug Perspektive.

Jetzt setzten wir beim printf in der for Schleife und beim return jeweils einen Breakpoint. Dazu vor der Zeilennummer (20 bzw 23) einen Doppelklick ausführen. Der Blaue Punkt in der Zeile kennzeichnet einen gesetzten Breakpoint.

Die Ausführung des Beispiel Codes beginnen wir mit Klick auf Resume (grüner Pfeil nach rechts) bzw. durch F8. 

 Jetzt wird das Programm bis zum gesetzten Breakpoint in der for Schleife ausgeführt. Die Ausgabe der gestarteten Debug Sitzung und das Hello World des Beispiels kann man in der Konsole sehen.

 Durch wiederholtes Betätigen von Resume (F8) wird das Programm weiter ausgeführt und der Fortschritt kann wieder in der Konsole begutachtet werden.

Jetzt können wir mit Eclipse erfolgreich ein Projekt für das Raspberry Pi kompilieren, übertragen und ausführen.
<< Teil 2                                                                 Übersicht

Teil 2: „Hello World“ mit Eclipse IDE

Im Zweiten Teil geht es darum, wie Eclipse als Entwicklungsumgebung eingerichtet wird. Ich zeige hier wie mit Hilfe von Eclipse ein einfaches „Hello World“ geschrieben und gebaut wird. Dazu erläutere ich wie ein Eclpise workspace eingerichtet und konfiguriert wird, wie ein Projekt angelegt und konfiguriert wird und wie das Programm geschrieben und gebaut wird, damit es auf dem Raspberry Pi ausgeführt werden kann. Im letzten Schritt zeige ich eine einfache Möglichkeit das Programm auf das Raspberry Pi zu kopieren und auszuführen.

Java installieren

Um Eclipse zu nutzen muss zunächst eine Java Platform installiert werden. Hier verwende ich die f reie Implementierung OpenJDK. Dazu öffnen wir ein Terminal und geben folgendes Kommando ein:

sudo apt-get install openjdk-7-jdk

Eclipse installieren

1. Anschließend laden wir uns von folgendem Link die Aktuelle Version von Eclipse IDE for C/C++ Developers" für 32bit herunter.

https://eclipse.org/downloads/

2. Wenn der Download abgeschlossen ist, entpacken wir das Archivin das rpi_tools Verzeichnis. Hier wieder den korrekten Pfad an den eigenen Usernamen anpassen.

tar -xvzf eclipse-cpp-luna-SR1a-linux-gtk.tar.gz -C /home/ubuntu/rpi_tools/

Eclipse starten 

1. Wechsle in das Verzeichnis eclipse

cd /home/ubuntu/rpi_tools/eclipse 

2. Starte eclipse mit folgendem Kommando 

./eclipse & 

Workspace einrichten

Wenn alles funktioniert fragt eclipse wo der workspace angelegtwerden soll.
Hier wählen wir

/home/ubuntu/rpi_tools/workspace

und setzten den Hacken bei Use this and do not ask again

Hello World Projekt erstellen

Jetzt wo wir den workspace erstellt haben, sind wir soweit das Hello World Projekt anzulegen.

1. Dazu erstellen wir ein neues C-Projekt unter: File, New, C-Projekt



2.Im Projekt Dialog:

• Name „test“
• Projekt Typ Executable, "Hello World ANSI C Project", und wählen als Toolchain Cross GCC
• und klicken dann auf Next 

3. Basic Settings 

• Hier tragen wir als Author unseren Nuzternamen ein und klicken Next. 

4. Select Configurations 

• Hier brauchen wir vorerst nichts einzutragen und gehen mit Next weiter. 

5. Cross GCC Command

• Hier müssen wir unsere Toolchain eintragen. 
• Cross compler prefix: arm-linux-gnueabihf- 
• Cross compiler path: /home/ubuntu/rpi_tools/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin 
• Mit Klick auf Finish haben wir unser Projekt erfolgreich angelegt. 

Hello World Projekt schreiben und bauen 

Da ich als Projekt Typ "Hello World ANSI C Project" gewählt habe, richtet Eclipse für uns schon die entsprechenden Code Zeilen ein. Wir fahren mit Punkt 5 der folgenden Auflistung fort. Wenn „Empty Project“ gewählt wurde, müssen zunächst die Punkte 1-4 abgearbeitet werden:

1. Rechtsklick auf test project und New, Source File wählen

2. Als name geben wir Test.c ein und klicken Finish.

3. Jetzt geben wir folgenden Text in den Editor ein:

#include "stdio.h"
#include"stdlib.h"

int main(void)
 {

     printf("!!!Hello World!!!\n");

     return EXIT_SUCCESS;

}

4. Anschließend speichern wir die Datei mit File, Save.

5. Jetzt wählen wir das project menu, Build Project

• Das Ergebnis der Kompilierung durch Klick auf das Console Tab angesehen werden. 
• Mit Klick auf den Tab Problems, können die Fehler bei der Kompilierung angesehen werden. 

 6. Wenn alles erfolgreich war erscheint im Project Explorer unter Binaries unser fertiges Hello World Programm test.

Hello World Ausführen 

Da wir das Hello World Programm mit unserer Cross Compiler Toolchain für das Raspberry Pi gebaut haben, können wir es nicht auf dem Host sondern nur auf dem Pi ausführen. Dazu ist es aber notwendig, dass wir es zuerst auf das Raspberry Pi kopieren. Dazu nutzen wir Secure Copy (scp) um das Programm via SSH auf das Raspberry zu übertragen.

1. Ein Terminal öffnen und in unser Projektverzeichnis wechseln. Das Programm liegt im Unterordner debug 

cd /home/ubuntu/rpi_tools/workspace/test/Debug 

2. scp können wir durch folgendes Kommando aufrufen

scp "file" "username"@"IP address":"Destination"

• "file" Ist der Name unseres Binaries. 
• "username" Ist der Username auf dem Raspberry Pi mit dem man sich per SSH anmelden kann. 
• "ip address" Ist die Raspberry Pi IP Adresse 
• "destination" Ist der Pfad in dem die Datei auf dem Raspberry kopiert werden soll.

Für dieses Beispiel lautet das Kommando also:

scp test pi@192.168.2.112:/home/pi/test 

Enter, Password eingeben,Fertig

3. Jetzt melden wir uns mittels SSH am Raspberry an

ssh pi@192.168.2.112 

Enter, Password eingeben 

4. Im Home Verzeichnis des users pi befindet sich das „Hello World“ Programm. 5. Dieses Starten wir mit:

./test 

  Wenn alles geklappt hat sehen wir folgendes Ergebnis:

!!!!Gratulation!!! 

Wir haben unser erstes Programm für das Raspberry Pi geschrieben, cross kompiliert und ausgeführt.

<< Teil 1                                                   Übersicht                                     Teil 3 >>

Teil 1: Download und Einrichtung der Toolchain

Um unter Ubuntu für das Raspberry Pi Programme zu entwickeln wird eine passende Toolchain, bestehend aus dem eigentlichen Compiler, zusätzlichen Tools (Linker, Assembler, etc.) und einigen Bibliotheken benötigt. Glücklicherweise muss man diese nicht selbst zusammenstellen, sondern es reicht die offizielle Toolchain aus dem Raspberyy Pi git Repository zu installieren.

Download der Cross Compiling Toolchain ( pre-built bmc2708 compiler)

Dazu wird zunächt GIT auf dem Host benötigt. Falls dies noch nicht installiert ist, kann dies mit folgender Zeile nachgeholt werden. Mit diesem wird die offizielle Toolchain von github.com auf den Host heruntergeladen / geklont.

sudo apt-get install git 

Im Home Verzeichnis ein Ordner „rpi_tools“ anlegen.

mkdir rpi_tools 

In diesen wechseln

cd rpi_tools

und dann das Repository herunterladen/klonen

git clone git://github.com/raspberrypi/tools.git --depth 1

Wenn dies abgeschlossen ist (dies kann einige Minuten dauern), befindet sich die Toolchain im folgenden Verzeichnis rpi_tools/tools/arm-bcm2708. Daher wechseln wir in dieses:

cd tools/arm-bcm2708

und schauen uns den Inhalt an

ls

Im Verzeichnis arm-bcm2708 befinden sich folgende vier Unterordner, welche alle eine Toolchain enthalten:

• arm-bcm2708hardfp-linux-gnueabi 
• arm-bcm2708-linux-gnueabi 
• gcc-linaro-arm-linux-gnueabihf-raspbian 
• gcc-linaro-arm-linux-gnueabihf-raspbian-x64 

Da in diesem Beispiel ein 32bit Ubuntu verwendet wird, müssen wir uns für die dritte Toolchain „gcc-linaro-arm-linux-gnueabihf-raspbian“ entscheiden. Für ein 64bit Linux müsste Nummer vier „gcc-linaro-arm-linux-gnueabihf-raspbian-x64“ verwendet werden.

Zunächst wollen wir die Funktionsweise testen und wechseln in das Verzeichnis unser Toolchain

cd gcc-linaro-arm-linux-gnueabihf-raspbian

und rufen den gcc aufrufen

arm-linux-gnueabihf-gcc -v

Wenn alles erfolgreich ist sehen wir, dass der gcc in Version 4.8.3 installiert wurde.

Damit wir die Toolchain Systemweit einsetzten können müssen wir noch folgende Einstellung an der PATH Variable vornehmen:
Wir wechseln in unser Homeverzeichnis

cd

und öffnen die Konfigurationsdatei für die Bash

nano .bashrc

Am Dateiende tragen folgendes einfache

export PATH=$PATH:/home/ubuntu/rpi_tools/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin

Mit STRG + x und J speichern wir unsere Änderungen. Hier bitte den korrekten Pfad zur Toolchain eintragen. Bei mir liegt diese im Home Verzeichnis des Users ubuntu.

Nach einem Neustart des Terminals können wir die Aktualisierung prüfen:

arm-linux-gnueabihf-gcc -v

Wenn folgende Ausschrift erfolgt, haben wir die offizielle Toolchain erfolgreich eingerichtet.

Im zweiten Teil zeige ich, wie man mit Eclipse einrichtet und ein erstes "Hello World" Programm schreibt.

<<Übersicht                                                                                                    Teil 2 >>

Programmierung für das Raspberry Pi

Im folgenden werde ich beschreiben wie eine Programmierumgebung für das Raspberry Pi eingerichtet wird.

Host Voraussetzung:

• Ubuntu 14.04 32-bit (als Beispiel in einer Virtuellen Maschine) o. Ä. Linux Distribution
• 10 GB freier Speicherplatz
• 2 GB RAM oder mehr

Target Voraussetzung: 

• Raspberry Pi 
• OS: Raspbian, Raspbmc 
• Netzwerkverbindung zum Host 
• SSH Zugang

Teil 1: Download und Einrichtung der Toolchain

Im ersten Teil beschreibe ich, wie unter Ubuntu eine Cross-Compiler Toolchain eingerichtet wird. Dies ist notwendig, da die Programme auf der Hostplatform entwickelt werden, aber auf dem Raspberry Pi laufen sollen. Grundsätzlich könnte dies auch auf dem Raspberry Pi direkt getan werden, aber besonders bei größeren Projekten bietet der Host PC deutliche Geschwindigkeitsvorteile.

Teil 2: „Hello World“ mit Eclipse IDE 

Prinzipiell könnte man die gesamte Programmierung auch mittels Texteditor und Kommandozeile umsetzten. Ich finde es aber bequemer dies mit einer Entwicklungsumgebung zu tun. Im zweiten Teil zeige ich daher, wie man dazu die Eclipse IDE einrichtet, ein einfaches „Hello World“ schreibt und dieses auf dem Raspberry Pi ausführt.

Teil 3: Remote Debugging

Im dritten Teil beschäftige ich mich mit der Einrichtung einer Debugging Session unter Eclipse. Damit ist es möglich das Programm auf dem Host Zeile für Zeile zu durchlaufen und im Hintergrund wird es auf dem Raspberry Pi ausgeführt. Dies ist vor allem bei der Fehlersuche unumgänglich.

>>Teil 1