UUID von Festplatte auslesen

Mit Hilfe der UUID kann eine Festplatte eineindeutig identifiziert werden. Dies ist zum Beispiel bei der Editierung der fstab hilfreich. Um die UUID und den zugehörigen mount Point herrauszufinden, kann mittels ls der Pfad /dev/disk/by-uuid ausgelesen werden.

Beispiel:

$ ls -l /dev/disk/by-uuid
lrwxrwxrwx 1 root root 10 Dez  2 18:02 a2158a1a-6ab7-45d1-****-************ -> ../../sda1

Raspberry Pi: Kernel Ausgabe

Mit der Datei /boot/cmdline.txt kann u.A. die Ausgabe des Linux Kernels auf der virtuellen Konsole und/oder der seriellen Schnittstelle (de)aktiviert werden.

Um die Datei zu bearbeiten muss diese mit einem beliebigen Editor geöffnet werden.

z.B. 

$vi /etc/inittab

Aktivierung der Kernel Ausgabe auf der seriellen Schnittstelle ttyAMA0: 

otg.lpm_enable=0 console=ttyAMA0 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Aktivierung der Kernel Ausgabe auf der virtuellen Konsole tty0: 

otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Aktivierung der Kernel Ausgabe auf der seriellen Schnittstelle ttyAMA0 und der virtuellen Konsole tty0: 

otg.lpm_enable=0 console=ttyAMA0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Wie man sieht wird die Ausgabe durch den Eintrag console=ttyX (de)aktivert. Wird keine Angabe gemacht, erfolgte bei meinen Versuchen die Ausgabe auf der virtuellen Konsole. Ob man die Kernel Ausgabe vollständig unterdrücken kann, habe ich nicht probiert.

Raspberry Pi: Login via Serial

Das Raspberry Pi verfügt über eine Serielle Schnittstelle, dessen Pins (TxD und RxD) auf dem Connector P1 verfügbar sind. 

Raspberry Pi Pinbelegung:

Die folgende Abbildungen zeigen die Pinbelegung für das Modell A und B. (Quelle: elinux)

Benötigt werden TxD0, RxD0 und GND. Als Gegenstelle dient z.B. ein USB2Serial - Wandler mit 3.3V Pegel (z.B. FTDI  TTL232R-3V3).

Raspberry Pi Login Konfiguration:

Standardmäßig ist das Raspberry Pi meist so konfiguriert, dass der Login über die serielle Schnittstelle nicht aktiv ist und nur die Ausgaben des Kernels ausgegeben werden. Um dies zu ändern muss die Datei  /etc/inittab angepasst werden. Dazu muss diese mit einem beliebigen Texteditor geöffnet werden,

$vi /etc/inittab

und folgende Zeile eingetragen werden. 

t0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100 

Damit wird der Login auf der serielle Schnittstelle (ttyAMA0) mit 115200 Baud im vt100 Mode aktiviert.

Der grafische Login wird mit folgender (oder ähnlicher) Zeile aktiviert.

0:2345:respawn:/sbin/getty -L tty0 115200

Um einen oder beide Login Modi zu deaktivieren, muss einfach die Zeile mit einem führenden # auskommentiert werden.

z.b.

#t0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Um die Änderungen zu übernehmen muss ein Reboot durchgeführt werden. Anschließend kann der Login über serielle Schnittstelle erfolgen.

Überprüfung

Mit dem Tool who kann man sich anzeigen wer angemeldet ist. Das folgende Beispiel zeigt die Ausschrift für aktive Anmeldung via der virtuellen Konsole tty0 und via serieller Schnittstelle ttyAMA0.

$who                                                            
root            tty0            00:00   Jan  1 00:01:17                      
root            ttyAMA0         00:00   Jan  1 00:01:25

aktuelles runlevel herrausfinden

Um im laufenden System den aktuellen runlevel herrauszufinden, können folgende Möglichkeiten angewand werden.

Beispiel 1 Vorheriges und aktuelles Runlevel ausgeben:

$runlevel
N 2 

Hilfe:

Aufruf: runlevel [OPTION]... [UTMP]
Vorheriges und aktuelles Runlevel ausgeben.

Options:
  -q, --quiet                 reduce output to errors only
  -v, --verbose               increase output to include informational messages
      --help                  display this help and exit
      --version               output version information and exit

Die Systemdatei /var/run/utmp wird benutzt, solange keine alternative Datei
UTMP angegeben wird.

Beispiel 2:

$who -r
 Runlevel 2   2015-10-23 17:29

Hilfe:

Aufruf: who [OPTION]... [ DATEI | ARG1 ARG2 ]
Informationen über gerade angemeldete Benutzer ausgeben.

  -a, --all         dasselbe wie -b -d --login -p -r -t -T -u
  -b, --boot        Zeit des letzten Rechnerstarts („system boot“)
  -d, --dead        tote Prozesse ausgeben
  -H, --heading     Kopfzeile mit Spaltenbezeichnungen ausgeben
      --ips         print ips instead of hostnames. with --lookup,
                    canonicalizes based on stored IP, if available,
                    rather than stored hostname
  -l, --login       Login‐Prozesse des Systems ausgeben
      --lookup      versuchen, den Rechnernamen mittels DNS zu kanonisieren
  -m                nur Rechnernamen und Benutzer, die die Standardeingabe
                      verwenden
  -p, --process     aktive Prozesse ausgeben, die von init aufgerufen wurden
  -q, --count       alle Loginnamen und Anzahl der angemeldeten Benutzer
  -r, --runlevel    aktuellen Runlevel ausgeben
  -s, --short       nur Namen, Leitung und Zeit ausgeben (Vorgabe)
  -t, --time        das letztmalige Stellen der Systemuhr ausgeben
  -T, -w, --mesg    den Message‐Status des Benutzers als +, - or ? hinzufügen
  -u, --users       angemeldete Benutzer anzeigen
      --message     dasselbe wie -T
      --writable    dasselbe wie -T
      --help     diese Hilfe anzeigen und beenden
      --version  Versionsinformation anzeigen und beenden

Wenn keine DATEI angegeben ist, „/var/run/utmp“ nehmen. „/var/log/wtmp“ ist als
DATEI üblich. Wenn ARG1 ARG2 angegeben sind, wird -m angenommen:
gebräuchlich sind „bin ich“ oder „am i“.

Melden Sie Programmfehler für who (auf Englisch, mit LC_ALL=C) an bug-coreutils@gnu.org
GNU coreutils Homepage: 
Allgemeine Hilfe zur Benutzung von GNU-Software: 
Melden Sie Übersetzungsfehler für who an 
Für die vollständige Dokumentation starten Sie:
info coreutils 'who invocation'

Terminal leeren

Um unter linux den terminal Bildschirm zu löschen gibt es zwei Möglichkeiten:
1. Mit dem Kommando

$clear

2. Mit der Tastenkombination

Strg + l

Der wesentliche Unterschied besteht darin, dass clear in der history eingetragen wird und die Tastenkombination nicht.

Raspberry Pi: Swap deaktivieren

Auf GTKDB habe ich folgende Anleitung zur Deaktivierung der Swap-Datei gefunden. Der auf GTKDB beschriebene Weg bezieht sich auf das Raspbian Image von 2013-02-09, funktioniert aber auch unter Raspbian mit Debian Version 7.8.

Die Kontrolle über das Swapfile erfolgt mittels dphys-swapfile. Hier zusammengefasst der Ablauf zur Deaktivierung:
1.  Swap Status überprüfen

$swapon -s

    Sieht die Ausgabe wie folgt aus, ist swap bereits deaktiviert,

 Filename                Type        Size    Used    Priority

     Für den Fall das swap aktiv ist, wird der swap Dateiname und die Größe
     aufgelistet.
2. Swap deaktivieren

$sudo update-rc.d dphys-swapfile remove

3. Reboot um Änderung zu übernehmen

$sudo shutdown -r now

(Optional)
Für den Fall das Swap wieder aktiviert werden soll, können folgende Schritte ausgeführt werden.
1. Swap aktivieren

$sudo update-rc.d dphys-swapfile defaults

2. Reboot um Änderung zu übernehmen

$sudo shutdown -r now

Zeroconf

Mit Zeroconf erfolgt eine Namensauflösung in lokalen Netzwerken. Dabei besteht keine Notwendigkeit für einen DNS-Server. Rechner können über Ihren Rechnernamen direkt angesprochen werden. Es ist dabei nicht relevant, ob diese über statische IPs oder per DHCP konfiguriert werden.

Jeder Rechner erhält einen Rechnernamen nach folgendem Schema: hostname.domainname

Anschließend kann jedes Programm des Rechners (z.b. Browser, SSH) über diesen Namen angesprochen werden.

Unter Linux ist die Zeroconf Technik durch avahi verfügbar. Die installation erfolgt durch:

$ sudo apt-get install avahi-daemon

Die Konfiguration erfolgt über /etc/avahi/avahi-daemon.conf

Die wesentlichsten Angaben erfolgen unter dem Eintrag: [server]. Hier wird der hostname und die Domain eingetragen.

host-name=desktop
domain-name=local

Damit avahi mit anderen Programmen kommunizieren kann, muss DBUS in der Konfiguration aktiviert werden.

enable-dbus=yes

Um avahi anzuhalten oder zu starten werden folgende Methoden verwendet:

$ sudo service avahi-daemon start

$ sudo service avahi-daemon stop

Um den aktuellen Status zu erhalten wird

$ sudo service avahi-daemon status

   avahi-daemon start/running, process 12424

 verwendet.

Ich habe diese Konfiguration mit folgenden Varianten getestet:

- Linux Mint 17.2 Cinnamon 64-bit

- Raspbian GNU/Linux 7

Windows Batch

Windows Eingabeaufforderung öffnen

• Windows Button drücken
• cmd eingeben und mit Enter bestätigen

Dateien aneinander hängen (am Beispiel txt Dateien)

• Eingabeaufforderung öffnen
• mit cd in das Zielverzeichnis wechseln
• copy *.txt alle.txt
• exit  und Enter

Zeile(n) in einer Text Datei entfernen

• Eingabeaufforderung öffnen
• type "Datei" | findstr /v "Suchtext" > ergbnis.txt

• Erklärung:
• type:              gibt die Datei aus
• |:                    Pipe, leitet die Ausgabe von type an Eingabe von findstr um
• findstr:           sucht nach dem "Suchtext"
• /v:                  Gibt alle Zeilen aus, die den "Suchtext" nicht enthalten
• >ergbnis.txt:  Ausgabe von findstr wird in die Datei geschrieben

Erste Zeile aus Textdatei extrahieren

• Eingabeaufforderung öffnen
• set /p var= < "Datei.txt"
• echo %var%

• Erklärung:
• set:     Variable setzen
• /p:       setzt Variable auf Inputzeile
• var:    Variablenname
• =:       Zuweisung
• <: datei="" die="" ein="" li="" liest="" nbsp="" zeilenweise="">

Raspberry Pi 1-wire mit Device Tree Overlay

Am vergangenen Wochenende hatte ich wieder einmal Zeit mich mit meinem Raspberry Pi zu beschäftigen. Dabei wollte ich endlich die 1-wire Temperatursensoren DS18S20 in Betrieb nehmen. Da es hierfür schon eine unendliche Anzahl an Tutorials zu finden gibt, habe ich nicht damit gerechnet, dass es dabei Probleme gibt.

Also das erst beste Suchergebnis ausgewählt und die empfohlene Beschaltung umgesetzt.

Vom Raspberry Pi GPIO Header Pin1 für die 3,3V Stromversorgung und Pin 6 für die Masse verwendet. Die Datenleitung des DS18S20 wird an Pin7 GPIO4 angeschlossen. Wichtig ist ein Pull Up Widerstand zwischen 3,3V und der Datenleitung DQ des DS18S20. Da ich keine 4.7k zur Verfügung hatte, gehen auch 2 parallel geschaltete  9.76k Widerstände. 

Hier zwei Bilder zur Verdeutlichung:

Anschließend die beiden Kernel Module geladen:

sudo modprobe w1-gpio     
sudo modprobe w1-therm   

und hoffnungsvoll das Verzeichnis mit den "erkannten" Devices ausgelesen:

ls /sys/bus/w1/devices        

Aber das Ergebnis zeigte nicht den erhofften Temperatursensor, sondern das keiner erkannt wurde. Also alles von vorn und einen neunen Sensor angeschlossen. Aber wieder das selbe Ergebnis.

Jetzt doch noch einmal die Suchergebnisse nach ähnlichen Problemen durchsucht und schließlich die Ursache gefunden. Der aktuelle Raspberry Pi Kernel (3.18.17) und die Firmware verwendet jetzt zur Konfiguration und Verwendung der Module device tree (dt). Die entsprechende Dokumentation auf der Raspberry Pi Homepage findet man hier: device-tree.

Um die entsprechende Konfiguration umzusetzen muss die config.txt mit folgendem Kommando angepasst werden:

sudo nano /boot/config.txt  

Um das 1-wire Modul am GPIO Pin 4 zu aktivieren, muss folgendes am Ende in die config.txt eingetragen werden:

#device tree config 
dtoverlay=w1-gpio,gpiopin=4 

Anschließend das Board rebooten und ein neuen Versuch starten die "erkannten" Devices aufzulisten:

ls /sys/bus/w1/devices 
10-000802abebeb  10-000802ac2e82  w1_bus_master1 

Und siehe da, alles funktioniert wie gewünscht. Es werden jetzt zwei 1-wire Temperatursensoren angezeigt.

Um jetzt die Temperatur eines Sensors auszulesen, wechseln wir in das entsprechende Verzeichnis und lesen die w1_slave Datei aus.

cd /sys/bus/w1/devices/10-000802abebeb 
cat w1_slave 
2f 00 4b 46 ff ff 03 10 5b : crc=5b YES    
2f 00 4b 46 ff ff 03 10 5b t=23562            

Die erste Zeile enthält die CRC Summe und das positive Ergebnis der Prüfung. In der zweiten Zeile steht die Temperatur in 1/1000 °C.

Die hier ausgelesene Temperatur beträgt also 23,562°C.

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