Homepage Wiki Forum Buy

Einfache Entwicklungsumgebung

Aus GNUBLIN

Schwierigkeitsgrad Voraussetzung Gnublin Familie
Gnublin logo easy.png Einfache Kommandozeile, Netzwerk Grundwissen Alle


Inhaltsverzeichnis


In erster Linie geht es in diesem Artikel darum, verschiedene Programmierwerkzeuge so zu kombinieren, dass eine einfache Entwicklungsumgebung entsteht. So dass man in der Programmiersprache C unter Ubuntu (Hostsystem) Programme schreibt,cross-compiliert und sie dann anschließend auf das Gnublin (Targetsystem) kopiert.

Das alles wird an Hand eines Beispielprojektes in C erklärt. Bei dem Projekt geht es darum die LED auf dem Gnublinboard zum Blinken zu bringen.


C cpp fuer gnublin.png


Einrichtung der Entwicklungsumgebung

Das nachfolgende Bild skizziert den typischen Aufbau während der Entwicklungsphase mit dem Gnublin.

Konzept entwicklungsumgebung.png

Wie Sie bereits schon wissen, ist die RS232 Verbindung zwischen Host- und Targetsystem eine bidirektionale Kommunikationsverbindung. Diese Verbindungsart ist immer dann Sinnvoll, solange noch keine Netzwerkverbindung zwischen den beiden Systemen herrscht. Grundsätzlich immer dann, wenn der Bootloader oder das booten des Kernels aktiv ist. Nicht jedes System hat eine Netzwerkverbindung, aber gerade in der Entwicklungsphase macht es Sinn sich über eine Netzwerkverbindung mit dem Target zu verbinden.

Bauen Sie ihr System wie in der obigen Abbildung auf und richten Sie die RS232 Verbindung ein. Wie Sie die Netzwerkverbindung für ihr System richtig konfigurieren finde Sie auf folgender Seite.

Hat man keinen Netzwerkanschluss an Gnublin bzw. per USB oder Modul zur Verfügung, kann man mit dem "On-Board" eine Netzwerkkarte per USB emulieren. Diese ist der Fall der immer gehen sollte.

Das Makefile

Der Übersetzungsprozess von Quelltext zu Maschinencode steuern wir über ein Makefile. Für Gnublin Projekte gibt es ein fertiges Makefile als Vorlage, mit dem man einfach ein Programm z.B. lokal per Crosscompiler übersetzten kann, anschließend per Netzwerk zu Gnublin übertragen und von dort aus starten, oder man kann ebenfalls das Programm direkt übertragen dort übersetzten und ebenfalls dort starten.

Die wichtigsten Funktionen sind:


make setup

Die Enwticklungsumgebung benötigt ein paar Programme auf dem PC und Gnublin. Ruft man make setup auf, so wird alles notwendige auf beiden Systemen installiert.


make all

Übsetzt mit der lokal installierten Toolchain das C-Programm.


make run

Überträgt das übersetzte programm und startet es automatisch als Standardbenutzer


make run_root

Übeträgt das übersetzte Programm und startet es automatisch als Benutzer root.


Ein Beispielmakefile sieht wie folgt aus:

    CC = arm-linux-gnueabi-gcc-4.6 
    TARGET_IP = 192.168.0.182 
    TARGET_USER = gnublin 
    TARGET = main 
    SOURCES = led.c

Dazu später aber mehr.

Installation Entwicklungsumgebung

Die Entwicklungsumgebung besteht aus den folgenden Programmen bzw. Programmierwerkzeugen:

  • Gedit, ein einfacher Texteditor mit Syntax-Highlighting
  • Cross-Compiler, übersetzt den Quellcode in einen ausführbaren Code für das Gnublin "cross"
  • SSH, stellt die Netzwerkverbindung zwischen Host- und Targetsystem her
  • Makefile, automatisiert die Arbeitsschritte wie
  1. linken
  2. übersetzen in ausführbaren Code
  3. überspielen auf das Gnublin
  4. Applikation auf dem Gnublin starten


In den folgenden Abschnitten wird auf den Umgang und die Installation der Werkzeugen eingegangen, jedoch wird es keine Einführung in die Programme an sich geben. Falls Sie weitergehende Informationen bzw. Einführungen haben möchten, dann klicken Sie auf das jeweilige Programm.

Software auf dem Hostsystem nachinstallieren

Zuerst müssen diverse Softwarepakete auf dem Hostsystem (Desktop-PC) nachinstalliert werden. Öffnen Sie also eine Konsole und geben Sie mit Rootrechten folgenden Befehl ein.

user@dev-pc:~# apt-get install gedit-plugins gcc-4.6-arm-linux-gnueabi

Mit dem Befehl installieren Sie sich zum einen die Cross-Compile-Umgebung (Toolchain) und zum anderen Plugins für den Texteditor (gedit) nach.

Host- und Targetsystem konfigurieren

Damit man sich später auf dem Targetsystem anmelden kann, sollte ein Benutzer angelegt werden.

!Achtung:! Vorher wird dringends empfohlen die richtige Systemzeit auf dem Target einzustellen.

Um einen Benutzer anzulegen tippt man folgenden Befehl in die Konsole, welche mit dem Target verbunden ist, ein:

root@gnublin:~# adduser gnublin

Anschließend folgen diverse Abfrage unter anderem nach dem Passwort. Das Passwort und der Benutzer sind natürlich frei wählbar, aber für den Artikel gilt:

Benutzer: gnublin

Passwort: gnublin

Gerade in der Entwicklungsphase wird beim Kopieren von Daten oder beim Anmelden auf dem Hostsystem immer wieder nach dem Passwort gefragt, was nach der Zeit lästig werden kann. Daher macht es Sinn sich über die sogenannten Public-Key-Methode auf dem Targetsystem zu authentifizieren.

Dafür muss auf dem Hostsystem ein Schlüsselpaar erzeugt werden. Die Abfrage nach der "passphrase" sollte unbeantwortet und mit Enter bestätigt werden. Natürlich ist das eine Sicherheitslücke, aber in der Entwicklungsphase gehen wir davon aus, dass sowohl das Target- als auch das Hostsystem "quasi" nebeneinander liegen.

user@dev-pc:~# ssh-keygen -t rsa

Die Abfrage nach der "passphrase" sollte unbeantwortet und mit Enter bestätigt werden. Natürlich ist das eine Sicherheitslücke, aber in der Entwicklungsphase gehen wir davon aus, dass sowohl das Target- als auch das Hostsystem "quasi" nebeneinander liegen.


Der Public-Key muss noch auf dem Targetsystem abgelegt werden:

user@dev-pc:~# ssh-copy-id -i ~/.ssh/id_rsa.pub gnublin@IP

Für IP im obigen Befehl muss mit die IP-Adresse vom Gnublin eingegeben werden.

Nun kann man sich ohne Passwort auf dem Target System anmelden.

user@dev-pc:~# ssh gnublin@IP


Weiter geht es auf dem Hostsystem. Hier muss der Texteditor so angepasst werden, so dass in der Fußleiste eine Konsole erscheint. Öffne Sie dafür den Editor und klicken Sie auf "Bearbeiten->Einstellungen". Nun sollte sich ein neues Fenster öffnen mit verschiedenen Reitern. Interessant an der Stelle ist die Option "Eingebettetes Terminal" unter Plugins. Machen Sie dort ein Hacken wie im folgenden Bild.

Gedit plugin.png

Falls bei ihnen die Option "Python-Konsole" eingeschaltet ist können Sie diese, wenn Sie wollen, ausschalten.

Damit das eingebettete Terminal in der Fußleiste erscheint, klicken Sie auf "Ansicht->Fußleiste".

Jetzt sollte das Terminal in der Fußleiste erscheinen. Allerdings ist die Schrift mit der voreingestellten Farbe nicht lesbar. Darum sollten Sie folgenden Link folgen, um das Problem zu beheben.


Erste Demo-Anwendung

Zur Demonstration gibt es ein Beispielprojekt.


Jetzt muss nur noch das Beispielprojekt aus dem Internet gezogen und entpackt werden.


Nun sollte alles soweit vorbereitet sein, so dass Sie mit dem nächsten Abschnitt weitermachen können.


Öffne Sie nun den Texteditor "gedit". Wie man erkennen kann ist der Gedit grob gesagt in drei Bereiche aufgeteilt. Links die Seitenleiste für die Dateiverwaltungen, in der Mitte der eigentliche Editor und in der Fußleiste das Terminal.

Gedit aufteilung.png

öffnen Sie in dem Editor nun den Ordner mit den vier Beispieldateien.

  • makefile
  • led.c
  • led.h
  • main.c

Bevor wir nun auf die einzelnen Dateien eingehen, sollten wir vorher einfach mal den Automatismus des Makefiles ausprobieren. Dabei sind die wichtigsten Befehl ,die Sie in das Terminal eingeben müssen, folgende:

  • make all
  • make clean
  • make install

Die Befehle sollten selbsterklärend sein. "Make all" schmeißt den Cross-Compiler an.


arm-linux-gnueabi-gcc-4.6 -c -o led.o led.c
arm-linux-gnueabi-gcc-4.6 -c -o main.o main.c
arm-linux-gnueabi-gcc-4.6 -o main led.o main.o


Make clean "säubert" wenn man so will den Ordner. Also löscht die erzeugten Objektdateien.

rm led.o main.o -f main

Und mit "make install" kopieren sie mit Hilfe von SSH die fertige Applikation auf das Target System ohne das Passwort einzugeben.

scp main gnublin@192.168.0.182:/home/gnublin

Bevor das so reibungslos funktioniert müssen im makefile eventuell Einstellungen vorgenommen werden. Hauptsächlichen sollten folgende Variablen angepasst werden.

CC = arm-linux-gnueabi-gcc-4.6
TARGET_IP = 192.168.0.182
TARGET_USER = gnublin
TARGET = main
SOURCES = led.c

CC steht für den Cross-Compiler, der am Anfang der Artikels nachinstalliert wurde. Die TARGET_IP ist, wie der Name schon andeutet, die IP vom Targetsystem (GNUBLIN) und TARGET_USER der angelegte Benutzer. Eigentlich sollte nur die IP angepasst werden.

Jetzt können Sie die Applikation auf dem Gnublin ausprobieren. Öffnen Sie dafür ein neues Terminal und verbinden Sie sich über SSH auf das Gnublin.

ssh gnublin@IP

Auch hier muss die IP angepasst werden. Wenn nicht schon geschehen, wechseln Sie in das Verzeichnis:

cd /home/gnublin

und wechseln Sie den Benutzer:

su

Anschließend führen Sie die Applikation aus.

./main

Nun sollte die LED auf dem GNUBLIN im Sekunden Takt blinken.

Quellen