1.1   Schnellstart

Um mit dem Gnublin Board zu arbeiten, muss man nur zwei Sachen haben:

1. Eine Micro SD Karte mit vorinstalliertem GNU/Linux.
2. Eine USB Verbindung zwischen der USB Konsolenbuchse auf dem Gnublin Board und einem Entwicklungsrechner (PC) unter GNU/Linux.

Auf dem PC startet man nach dem Anstecken des USB Kabel ein Terminal Emulationsprogramm, z.B. picocom:

sudo picocom -b 115200 /dev/ttyUSB0

Tipp: Aus picocom steigt man wieder aus mit Strg-A Strg-X.

Damit wird der PC zur "Konsole" des Gnublin Boards, das heisst, man sieht die Meldungen des Boards auf dem Bildschirm und Tastatureingaben auf dem PC werden auf das Board weitergeleitet.

Warum ist es wichtig, dass man zuerst die USB Verbindung herstellt und dann das Terminalprogramm startet? Die Antwort ist, dass durch Einstecken des Kables erst eine virtuelle serielle Schnittstelle auf dem PC angelegt wird, diese heisst in der Regel /dev/ttyUSB0, die Zahl am Ende kann auch grösser sein. Erst danach kann picocom mit diesem Gerät als Argument gestartet werden.

Was passiert nach dem Anstecken?

Nachdem das Board über das Konsolen USB Kabel angesteckt wurde, lädt es von der SD Karte zunächst den Apex Bootloader (http://elinux.org/APEX_Bootloader) und führt ihn aus. Der Bootloader ist so konfiguriert, dass er nach einer kurzen Wartepause den Linux Kern von der SD Karte in den Speicher kopiert und dann ausführt. Linux bootet nun und mountet am Schluss das Root Filesystem von der SD Karte. An der Konsole sollte man nun sehen:

...
EDLK (Built by Poky 5.0) 5.0 armv5te ttyS0

armv5te login:

Jetzt kann man sich mit dem Namen root anmelden (ohne Passwort) und sieht dann diesen Prompt:

root@armv5te:~#

Nun kann man mit Gnublin (fast) wie auf einem gewöhnlichen GNU/Linux Rechner arbeiten. Das Root Filesystem enthält mit über 600 MByte Grösse eine sehr grosse Auswahl an Programmen, allerdings auch Programme, z.B. das X Window System, das die Gnublin LPC3131 Hardware nicht unterstützt. Auch der mit 8 MByte eher kleine SDRAM Arbeitsspeicher ist für manche Anwendungen zu knapp, z.B. um mit dem GNU C Compiler ein grösseres Programm nativ für den ARM9 zu kompilieren, obwohl es prinzipiell funktioniert.

Die Micro SD Karte

Die benötigte Micro SD Karte ist entweder bei der Lieferung des Gnublin Boards mit dabei oder kann selber mit dem Programm gnublin-card.py hergestellt werden. Der folgende Abschnitt geht darauf ein.

Was kann man mit dem Board machen?

Hier sind ein paar Beispiele, was man mit dem Board machen kann.

• Man kann mit dem Board Embedded Linux auf einem ARM Mikrocontroller kennenlernen.

• Über die USB OTG high-speed Schnittstelle kann man Gnublin sowohl als USB Gerät an einen USB Host anstecken, z.B. einen PC, oder man kann Gnublin als USB Host zur Ansteuerung von fast beliebigen USB Geräten verwenden.

  So kann man Gnublin z.B. über einen USB zu Ethernet Adapter mit einem Computernetzwerk verbinden und alle üblichen Protokolle verwenden, wie z.B. HTTP, SSH, FTP und so weiter.

  So ein Adapter kostet nur ein paar Euro. Auf der Abbildung img/usb-ethernet.jpg sieht man so einen Adapter. Mit Hilfe eines USB Adapterkabels kommt man von der Mini USB OTG Buchse auf dem Gnublin Board an ein USB Gerät mit "normalem" USB Stecker. Die Abbildung img/usb-adapterkabel.jpg zeigt zwei Varianten von solchen Adaptern.

  Am Gnublin Board funktionieren auch USB-WLAN Adapter, wie z.B. der ASUS WL-167G, siehe Abbildung img/usb-wlan.jpg.

  Weiter unten beschreibe ich, welche Kernelmodule man für diese Adapter verwenden muss.

• Über die herausgeführten I2C und SPI Schnittstellen kann man viele Hardware-Erweiterungen anschliessen, z.B. Sensoren, Funkmodule. Es steht nichts im Weg um Sensoren einzulesen, z.B. Temperatur und Luftfeuchtigkeit, und die eingelesenen Werte über einen Webserver auszuliefern.

• Über ein paar herausgeführte GPIO Leitungen kann man Experimente mit Interrupts machen und z.B. die Interrupt-Antwortzeit messen. Das führt zu dem interessanten Gebiet "Realtime Linux".

• Gebäudeautomatisierung

• Tragbare Embedded Linux Geräte

• Fahrrad-Computer

• Vieles mehr

An wen wendet sich das Gnublin Projekt?

Ich stelle mir folgende Benutzergruppen und Ihre Interessen vor:

Anfänger

• Was ist Embedded Linux?

  • Kennenlernen der Einzelteile Bootloader, Kernel und Filesystem.
  • Kennenlernen eines Mikrocontrollers mit ARM Kern.
  • Kennenlernen der Open-Source Entwicklungsmethodik.

• Wie starte ich Gnublin?

• Wie logge ich mich ein?

• Wie kann ich mit einfachen Kommandos auf die Schnittstellen GPIO, SPI und I2C zugreifen?

• Wie baue ich eine einfache Anwendung mit Hilfe einer Interpretersprache, z.B. mit Hilfe eines Shell-Skripts oder der Sprache Python. Einfache Anwendungen sind

  • Leuchtdioden ein-/ausschalten
  • Taster einlesen
  • Alphanumerische Displays über SPI anschliesssen

• Wie kann ich das selbstgemachte Programm nach dem Booten automatisch ausführen lassen?

Fortgeschrittene

• Den vorhandenen Kernel neu konfigurieren, übersetzen und installieren.
• Neue vorhandene Module in den Kernel einbinden.
• Einfache Änderungen am vorhandenen Root Filesystem machen.
• Das vorhandene Root Filesystem nach eigenen Vorlieben neu kompilieren und installieren.
• Vorhandene Programme für Gnublin crosskompilieren und installieren.
• Eigene Programme für Gnublin in C zu schreiben.

Gurus

• Eigene Kernelmodule schreiben und installieren.
• Einen eigenen Kernel anpassen, so dass er auf Gnublin läuft.
• Eigene Erweiterungen in den Apex Bootloader einbauen.
• Selber ein Root Filesystem für Gnublin zusammenbauen, ohne die Vorgabe durch das ELDK.
• Tiefer in die technischen Details des LPC3131 ARM926 Mikrocontrollers einsteigen, z.B. alternative Möglichkeiten zum Booten ausprobieren.
• Experimente mit Echtzeit-Linux, z.B. Xenomai oder der Echtzeit Erweiterung für den GNU/Linux Kern.

3.1   Digitale Ein-/Ausgänge ansteuern

Belegung der GPIOs:

GPIO3...........LED1
GPIO11..........X4-2  J5-12
GPIO13..........
GPIO14..........X4-3  J5-11
GPIO15..........X4-4

Nun soll beispielhaft die LED1 (rot) an GPIO3 ein- und ausgeschaltet werden.

Beispielcode für Ausgabe

Mit sysfs auf der Kommandozeile:

root@armv5te:/sys/class/gpio# ls
export     gpiochip15  gpiochip58  gpiochip68  gpiochip91  unexport
gpio3      gpiochip47  gpiochip61  gpiochip84  gpiochip95
gpiochip0  gpiochip57  gpiochip64  gpiochip86  gpiochip96

root@armv5te:/sys/class/gpio# cd gpio3/
root@armv5te:/sys/devices/virtual/gpio/gpio3# ls
active_low  direction  edge  power  subsystem  uevent  value

root@armv5te:/sys/devices/virtual/gpio/gpio3# echo "high" > direction
root@armv5te:/sys/devices/virtual/gpio/gpio3# cat direction
out

root@armv5te:/sys/devices/virtual/gpio/gpio3# echo 1 > value
root@armv5te:/sys/devices/virtual/gpio/gpio3# echo 0 > value
root@armv5te:/sys/devices/virtual/gpio/gpio3# echo 1 > value

Mit einem Shell Skript:

# Blink the onboard LED
# http://blog.makezine.com/archive/2009/02/blinking-leds-with-the-beagle-board.html

GPIO=3

cleanup() { # Release the GPIO port
  echo $GPIO > /sys/class/gpio/unexport
  exit
}

# Open the GPIO port ('high' direction is output)
#
echo $GPIO > /sys/class/gpio/export
echo "high" > /sys/class/gpio/gpio$GPIO/direction

trap cleanup SIGINT # call cleanup on Ctrl-C

# Blink forever
while [ "1" = "1" ]; do
  echo 1 > /sys/class/gpio/gpio$GPIO/value
  sleep 1
  echo 0 > /sys/class/gpio/gpio$GPIO/value
  sleep 1
done

cleanup # call the cleanup routine

Mit einem Lua Script:

-- blink.lua

GPIO = 3

function wait(n)
  os.execute("sleep " .. tonumber(n))
end

function cmd(c)
  print(c)
  os.execute(c)
end

cmd("echo " .. GPIO .. " > /sys/class/gpio/export")
cmd("echo out > /sys/class/gpio/gpio" .. GPIO .. "/direction")

n = 0
while n < 2 do
   cmd("echo 1 > /sys/class/gpio/gpio"..GPIO.."/value")
   wait(1)
   cmd("echo 0 > /sys/class/gpio/gpio" .. GPIO .. "/value")
   wait(1)
   n = n + 1
end

cmd("echo "..GPIO.." > /sys/class/gpio/unexport")

Mittlerweile habe ich den Lua Interpreter um os.path_exists() erweitert, so dass man prüfen kann, ob Dateien und Verzeichnisse existieren:

-- blink2.lua
-- H. Hoegl, 21. Dec 2011

if os.path_exists("/sys/class/gpio/gpio11") == 1 then
   print("remove gpio pin")
   f = io.open("/sys/class/gpio/unexport", "w")
   f:write("11")
   f:close()
else
   print("create gpio pin")
   f = io.open("/sys/class/gpio/export", "w")
   f:write("11")
   f:close()
end
-- und so weiter...

Weitere Interpretersprachen für solche Experimente sind Tcl, besonders die kleinere Variante "Jim Tcl", siehe jimsh, und Perl. Squirrel (sq) als Abkömmling von Lua würde sich auch eignen. Auch Python wäre möglich, allerdings braucht der (grosse) Interpreter lang zum Laden und er läuft bei 8 MByte auch nicht richtig rund.

Beispielcode für Eingabe

Mit der Shell:

#!/bin/sh

GPIO=11

cleanup() { # Release the GPIO port
  echo $GPIO > /sys/class/gpio/unexport
  exit
}

echo $GPIO > /sys/class/gpio/export
echo "in" > /sys/class/gpio/gpio$GPIO/direction

trap cleanup SIGINT # call cleanup on Ctrl-C

while [ "1" = "1" ]; do
   cat /sys/class/gpio/gpio$GPIO/value
   sleep 1
done

cleanup # call the cleanup routine

Mit einem Squirrel Skript:

/* input.nut */
local s, GPIO;

GPIO = 11;

s = "echo " + GPIO + " > /sys/class/gpio/export";
print(s+"\n");
system(s);

s = "cat /sys/class/gpio/gpio" + GPIO + "/value";
print(s+"\n");
system(s)

s = "echo " + GPIO + " > /sys/class/gpio/unexport";
print(s+"\n");
system(s);

Beispielcode für Interrupts

XXX to do

Das folgende Foto zeigt, wie ein Taster an den GPIO11 Pin angeschlossen wird. Den Taster habe ich aus einem alten Gerät ausgebaut.

Die Schaltung sieht dabei so aus:

Taster an GPIO11

      VCC 3.3V
         |
        10K
 __T__   |
 o   o---+------> GPIO11 (weiss/blau)
 |
===
GND (blau)

3.2   Die SPI Schnittstelle

Die SPI Signale sind auf dem Stecker J5 wie folgt herausgeführt:

SPI_MOSI........J5-7
SPI_MISO........J5-8
SPI_CLK.........J5-10

Die Signale SPI_CS_OUT0 und SPI_CS_IN sind als Testpunkte herausgeführt. Die Abkürzung CS bedeutet "Chip Select".

Die anderen Chip Select Signale SPI_CS_OUT1 (UART_CTS_N) und SPI_CS_OUT2 (UART_RTS_N) sind nicht herausgeführt.

So gehen wir vor (XXX to do):

• Treiber spidev ist bereits im Kernel fest eingebaut.

• Der MTD Kerneltreiber für DataFlash Speicher darf im Kernel nicht aktiviert sein, da er auch die SPI Schnittstelle (Chip Select 0) verwendet und andere Anwendungen dadurch nicht mehr darüber kommunizieren können.

• Eintrag spi_lpc313x.0 in /sys/devices/platform soll vorhanden sein.

  root@armv5te:/sys/devices/platform/spi_lpc313x.0# ls
  
  driver  modalias  power  spi0.0  spi_master  subsystem  uevent
  

• Eintrag in /sys/class/spi_master/

  root@armv5te:# ls /sys/class/spi_master/spi0
  device    power  subsystem  uevent
  

• Die Gerätedatei heisst /dev/spi0. Falls es sie nicht gibt, legt man sie mit dem Kommando

  mknod /dev/spi0 c 153 0
  

  an.

• Demoprogramm spidev_test_2 auf Gnublin starten. Man findet es in $GNUBLINDIR/work_eplpc3131/prog/spi/.

  

  Dieses Oszilloskopbild zeigt das Programm spidev_test_2, das die fünf Byte 0xF0, 0xAA, 0x0F, 0xAA und 0x55 auf die SPI Schnittstelle schreibt. Der obere Kanal ist der Takt SCK, der untere Kanal ist das MOSI Signal. Der MISO Eingang blieb offen, deswegen haben alle eingelesenen Bytes den Wert 0xFF.

3.3   Die I2C Schnittstelle

Der LPC3131 hat zwei separate Schnittstellen. Gnublin führt in der Version 1.2 nur die zweite Schnittstelle (I2C_SDA1, I2C_SCL1) heraus. Die erste (Index 0) ist nicht beschaltet.

Belegung:

I2C_SDA1.......J5-6
I2C_SCL1.......J5-5

Vorgehen:

• PCA9555D I/O Expander für I2C. Die über die Pins A0, A1 und A2 kodierten I2C Adressen sind 0x20 (schreiben) und 0x21 (lesen). Siehe Datenblatt.

• Kernel-Modul pca953x.

• Device anlegen:

  root@armv5te:~# echo /dev/pca9555 0x20 > /sys/bus/i2c/devices/i2c-1/new_device
  i2c i2c-1: The new_device interface is still experimental and may change in a near future
  i2c i2c-1: new_device: Instantiated device /dev/pca9555 at 0x20
  root@armv5te:~#
  

  Danach gibt es aber das Device /dev/pca9555 noch nicht.

• Device erstellen:

  root@armv5te:~# mknod /dev/pca9555 c 89 1
  

• Devices auflisten:

  root@armv5te:~# ls -l /sys/bus/i2c/devices/
  0-0060 -> ../../../devices/platform/pnx-i2c.0/i2c-0/0-0060
  1-0040 -> ../../../devices/platform/pnx-i2c.1/i2c-1/1-0040
  i2c-0 -> ../../../devices/platform/pnx-i2c.0/i2c-0
  i2c-1 -> ../../../devices/platform/pnx-i2c.1/i2c-1
  
  ls /sys/class/i2c-adapter/i2c-1/
  1-0040         device   name        power      uevent
  delete_device  i2c-dev  new_device  subsystem
  
  ls /sys/devices/platform/pnx-i2c.1/
  driver  i2c-1  modalias  power  subsystem  uevent
  

• Demo Programm:

  $GNUBLINDIR/work_eplpc3131/prog/i2c-pca9555.

  Programm starten:

  root@armv5te:~/i2c-pca9555# ./i2c-test /dev/pca9555
  

  Nun sollte eine LED an irgend einem Pin des Port0 vom PCA9555 blinken.

• Achtung: Bei der I2C Busadresse des PCA9555 muss man aufpassen. Im ersten Byte auf dem Bus ist die Slave Adresse nur 7 Bit gross (Bit 7 bis Bit1). Das nullte Bit ist das R/notW bit. Bei der Slave Adresse im Linux Anwendungsprogramm nimmt man nur die Bits 7 bis 1. Der PCA9555 mit allen drei Adress Bits A2, A2 und A0 gleich 0 hat daher die Slave Adresse 0x20.

• Auf dem folgenden Schirmfoto sieht man das erste Byte (Adresse) bei der I2C Übertragung zum PCA9555. Oben ist das Clock Signal SCL, unten das Datensignal SDA. Man sieht schön das Startbit, die Adresse 0x20, das Acknowledge Bit und das Stopbit.

  

• Literatur:

  • Atmel Application Note AVR32412: AVR32 AP7 TWI Driver
  • https://github.com/torvalds/linux/blob/master/Documentation/i2c/instantiating-devices

• Foto:

  

  Das Modul mit dem PCA9555D ist über Flugdrähte mit dem Gnublin Board verbunden. Die kleine Adapterplatine kann man unbestückt von http://www.roth-elektronik.com bekommen.

3.4   Die analogen Eingänge

Folgende analogen Eingänge des LPC3131 sind auf dem 14-poligen Erweiterungsstecker J5 herausgeführt:

ADC10B_GPA0........J5-1
ADC10B_GPA1........J5-2 (auch auf X4-1)
ADC10B_GPA3........J5-3

XXX to do: Es gibt noch keinen ADC Treiber im Kernel.

3.5   Der PWM Ausgang

Der PWM Ausgang PWM_DATA des LPC3131 ist auf J5-4 herausgeführt.

XXX to do: Es gibt noch keinen PWM Treiber im Kernel.

3.6   Die USB-OTG Buchse

Die Mini-AB Buchse hat einen ID Pin, der signalisiert, ob die "on-the-go" (OTG) Schnittstelle entweder als Device (ID=1 bzw. offen) oder Host (ID=0) arbeitet. Der ID Pin (Nummer 4) ist direkt dem GND Pin (Nummer 5). Schaut man von hinten auf die Buchse, ist Pin Nummer 5 ganz links.

Üblicherweise steuert die Art des angesteckten USB Kabels den Pegel des ID Pins. Steckt man ein USB Kabel mit einem Mini-A Stecker in die OTG Buchse, wird der ID Pin auf Masse gezogen, das heisst, die USB Protokollsoftware arbeitet damit als Host. Diese Art Kabel ist leider nicht sehr weit verbreitet, da das USB Standardisierungsgremium den Mini-A Stecker als "antiquiert" eingestuft hat. Wenn man sich nicht sicher ist, ob man es mit einem Mini-A Stecker zu tun hat, dann hilft dieser Tipp: Schaut man von vorne auf den Stecker, dann muss die Plastikisolierung darin die Farbe Weiss haben.

Im Gegensatz zum Mini-A Stecker ist der Mini-B Stecker noch ganz modern und auch erlaubt, so dass es viele USB Erweiterungskabel mit diesem Stecker gibt. Wenn man die Möglichkeit hat, den ID Pin der Buchse von Hand zu setzen, dann kann man auch diese Kabel zum Anstecken eines USB Gerätes an Gnublin verwenden. Die Version 1.2 des Boards kann das leider nicht. Man kann jedoch einen Jumper einlöten, wie man das in der folgenden Abbildung sieht.

Eine separat aufgeklebte Pfostenleiste erlaubt es über einen Jumper (blau, liegt daneben) den ID Pin der USB OTG Buchse auf Masse zu ziehen und damit die USB Host Funktion auszuwählen.

Die nächste Revision 1.3 des Boards, die gerade gemacht wird, wird diesen Jumper auf dem Board haben.

Zur Zeit werden USB OTG Verbindungen fast nur noch mit Micro-Steckern realisiert, die allerdings vom Aufbau her viel wackeliger wirken als die Mini-A/B Buchsen. Aus diesem Grund haben wir sie nicht bei Gnublin verwendet.

Das folgende Foto zeigt zwei weit verbreitete Adapter von USB A Buchse (links, zur Aufnahme von Geräten oder Kabeln mit Typ-A Steckern) auf Mini-B Stecker (rechts, zum Einstecken in die Gnublin USB-OTG Buchse). Diese Art Kabel kann ohne Tricks nicht dazu verwendet werden, um USB Geräte an den Gnublin USB Host anzuschliessen. Der Trick besteht darin, den ID Pin der USB-OTG Buchse separat über einen Jumper zu steuern.

6.1   Wichtige Apex Kommandos

Mit help bekommt man eine Liste aller Kommandos:

apex> help
sorting 29
 alias            - show or set aliases
 boot             - boot Linux
 checksum         - compute crc32 checksum
 clock            - Get clock speed
 compare          - compare regions
 copy             - copy data between devices
 crc              - compute crc32 checksum using lpc313x tables
 drvinfo          - list available drivers
 dump             - dump data to the console
 erase            - erase device region
 fill             - fill a region with a byte
 go               - execute program at address
 help             - list available commands
 image            - image handling
 info             - display information about a region descriptor
 mmc              - test MMC controller
 printenv         - show the environment
 reset            - reset target
 saveenv          - save environment to non-volatile memory
 setenv           - set environment variable
 unalias          - remove an alias
 unsetenv         - restore environment variable to default
 version          - show version and copyright
 wait             - wait before continuing
 xreceive         - receive data over the serial line

Ein paar oft gebrauchte Kommandos sind info, copy, printenv und boot.

apex> info ext2://1

./
../
lost+found/
zImage
etc/
...

apex> copy ext2://1/zImage 0x30008000

apex> printenv

ext2-drv *= mmc
cmdline *= console=ttyS0,115200n8 root=/dev/mmcblk0p1 rw rootwait
startup *= wait 2; copy ext2://1/zImage 0x30008000; boot
kernelsrc *= lnand:768k+2m
bootaddr *= 0x30008000
arch-number *= 9998

boot console=ttyS0,115200n8 root=/dev/mmcblk0p2 rw rootwait

6.2   Apex kompilieren

Der Apex Quelltext ist in $GNUBLINDIR/work_eplpc3131/apex/.

Anleitung:

1. Pfade und Umgebungsvariable der ELDK Toolchain setzen. Dazu gibt es das Shell Skript set.sh in $GNUBLINDIR/work_eplpc3131.

   So sieht set.sh aus:

   P1=/opt/eldk-5.0/armv5te/sysroots/i686-oesdk-linux/usr/bin/armv5te-linux-gnueabi/
   P2=/opt/eldk-5.0/armv5te/sysroots/i686-oesdk-linux/bin/armv5te-linux-gnueabi/
   export ARCH=arm
   export CROSS_COMPILE=arm-linux-gnueabi-
   export PATH=$P1:$P2:$PATH
   

   Dieses Skript wird "gesourced", man gibt dazu ein . ./set.sh.

2. Apex Quelltextverzeichnis anlegen:

   cd $GNUBLINDIR/work_eplpc3131/apex/
   tar zxvf apex-1.6.8.tar.gz
   mv apex-1.6.8 work_1.6.8
   

3. Patches anwenden:

   cd work_1.6.8
   patch -p1 < ../apex-1.6.8_lpc313x.patch
   patch -p1 < ../ep3131.patch
   

4. Kompilieren:

   make menuconfig
   make apex.bin
   

5. Apex auf die SD Karte schreiben. Ich nehme bei dem folgenden Kommando an, dass die Karte als /dev/sdb erkannt wurde und dass sich der Bootloader auf der zweiten Partition befindet:

   sudo dd if=src/arch-arm/rom/apex.bin of=/dev/sdb2 bs=512
   sync
   

   Man kann das auch mit dem gnublin-card.py Programm bequem erledigen, siehe die Beschreibung an anderer Stelle in diesem Text.

8.1   Umgebungsvariable

Um mit dem ELDK Cross-Compiler zu arbeiten, müssen ein paar Umgebungsvariable gesetzt werden. Ich habe in set.sh alles Wichtige zusammengefasst.

set.sh:

P1=/opt/eldk-5.0/armv5te/sysroots/i686-oesdk-linux/usr/bin/armv5te-linux-gnueabi/
P2=/opt/eldk-5.0/armv5te/sysroots/i686-oesdk-linux/bin/armv5te-linux-gnueabi/

export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabi-
export PATH=$P1:$P2:$PATH

Diese Datei muss man "sourcen", das heisst wie folgt aufrufen:

. ./set.sh

Die Datei set.sh ist in $GNUBLINDIR/work_eplpc3131/.

To Do

• Bootvorgang (init Skripte). Nötige Änderungen am unbehandelten ELDK 5.

• Paketverwaltung

• Alternative Root Filesysteme

  • Debian/ARM
  • Gentoo/ARM
  • Fedora/ARM
  • Linux-From-Scratch (LFS)

8.2   Das Root Filesystem

Das Root Filesystem findet man im installierten ELDK 5 auf dem PC an dieser Stelle:

/opt/eldk-5.0/armv5te/rootfs/

Man kann es mi/t ein paar kleineren Aenderungen direkt auf die Micro-SD Karte kopieren.

Ein angepasstes Root Filesystem findet man hier:

http://elk.informatik.fh-augsburg.de/pub/gnublin-lpc3131/

9.1   Bestehende Pakete cross-kompilieren

Folgende Programme habe ich ohne viel Aufwand für das Gnublin Board cross-kompiliert:

• curl
• lighttpd-1.4.29
• lynx-2.8.7
• lua-5.1.4
• mongoose
• netcat
• pcre-8.13
• pure-ftdp
• Python-2.7.1
• squirrel
• wget
• wireless_tools

Siehe $GNUBLINDIR/work_eplpc3131/cross-compiled/

Kurze Anleitung für lighttpd

• Pfade auf den ELDK Cross-Kompiler setzen:

  . ./set.sh
  

• pcre-8.13 kompilieren mit

  CC=arm-linux-gnueabi-gcc RANLIB=arm-linux-gnueabi-ranlib \\
  STRIP=arm-linux-gnueabi-strip LD=arm-linux-gnueabi-ld \\
  ./configure --host=arm-linux-gnueabi --enable-static
  

• lighttpd kompilieren mit

  CC=arm-linux-gnueabi-gcc RANLIB=arm-linux-gnueabi-ranlib \\
  STRIP=arm-linux-gnueabi-strip LD=arm-linux-gnueabi-ld   \\
  ./configure --host=arm-linux-gnueabi --disable-static \\
  --enable-shared --without-zlib --without-bzip2
  

9.2   Eigene Programme cross-kompilieren

XXX Hello World Demo