Aus RN-Wissen.de
Wechseln zu: Navigation, Suche


Das Raspberry Pi

Embedded Linux findet in immer mehr Bereichen Verwendung. Dementsprechend steigt auch die Anzahl preisgünstiger Entwicklungsboards die den Einstieg und den Umgang mit Embedded Linux erleichtern. Eines dieser Boards ist das Raspberry Pi.
Dieser Artikel soll Neulingen den Einstieg in die Welt des Embedded Linux erleichtern und dabei helfen etwas Erfahrung mit dem Raspberry Pi und den Umgang mit Linux zu sammeln.

Dieser Artikel ist noch lange nicht vollständig. Der Auto/Initiator hofft das sich weitere User am Ausbau des Artikels beteiligen.

Das Ergänzen ist also ausdrücklich gewünscht! Besonders folgende Dinge würden noch fehlen:

Mehr Grundlagen und vor allem mal praktische Programmbeispiele / Algorithmen etc.


Wofür das Ganze?

Das ist wohl die erste Frage die man sich stellt wenn man von so etwas wie dem Raspberry Pi oder anderen Embedded Systemen hört.
Es dürfte wohl klar sein, dass diese Boards komplett anders sind als ganz normale Mikrocontroller wie der Mega32 oder ein PIC. Aber im Gegenzug dazu bieten diese Systeme, im Vergleich zu Mikrocontrollern, eine immense Rechenpower.
Dadurch wird es möglich kleine und zugleich komplexe Systeme zu entwickeln. Ein einfaches Beispiel ist das aufnehmen von Videos. Videos können mit einem einfachen Mikrocontroller nur sehr bedingt aufgenommen werden und die Qualität ist alles andere als schön.
Ein Embedded System besitzt genug Rechenpower um diese Aufgabe problemlos zu bewältigen. Dies ist nur eine Aufgabe von vielen. Ohne Embedded Linux würden heute viele Geräte nicht so arbeiten wie sie es tun (IP-Kameras, Router, Webserver, usw.).

Die ersten Schritte

Herzstück dieses Boards ist ein BCM2835 SoC von Broadcom, der mit einer Taktfrequenz von 700MHz arbeitet. Ein SoC ist ein "System on a Chip" d.h ein komplettes System in Form eines einzigen ICs. Der BCM2835 beinhaltet 256MB RAM, einen ARM11 Prozessorkern und eine GPU. Das Raspberry Pi beinhaltet u.a. zwei USB-Ports, einen HDMI Anschluss, einen SD-Kartenslot und einen LAN Anschluss.

SD-Karten Setup (Debian "Squeeze")

Bevor ihr mit dem Raspberry Pi losgelegen könnt, müsst ihr erst eine SD-Karte mit einem Debian Image erstellt werden.
Hierbei ist darauf zu achten, dass ihr für die SD-Karte möglichst keine Class 10 Karte und keine Karte mit einer großen Speicherkapazität verwendet wird, da es bei diesen Karten mit sehr hoher Wahrscheinlichkeit vorkommen kann das diese vom Raspberry Pi nicht richtig erkannt wird.
Bei diesen zwei Karten kann ich jedoch versichern das sie funktionieren.

SD-Karte erstellen unter Windows

  1. Das Image unter: http://www.raspberrypi.org/downloads downloaden
  2. Den Win32 DiskImager unter: https://launchpad.net/win32-image-writer downloaden
  3. Das Image entpacken
  4. SD-Karte in einen Kartenleser einlegen
  5. Win32 DiskImager starten
  6. Die SD-Karte und das Image im DiskImager auswählen
  7. Auf "Write" klicken (VORSICHT: Alle Daten auf der Karte werden gelöscht)
  8. Sobald der Schreibvorgang abgeschlossen wurde auf "OK" klicken
  9. DiskImager schließen
  10. SD-Karte in das Raspberry Pi einlegen

SD-Karte erstellen unter MAC OS

SD-Karte erstellen unter Linux

  1. Das Image unter: http://www.raspberrypi.org/downloads downloaden
  2. Das Image entpacken
  3. Terminal öffnen und "ls /dev" eingeben
  4. SD-Karte in einen Kartenleser einlegen
  5. Im Terminal wieder "ls /dev" eingeben. Im Verleich zum vorherigen "ls /dev" sollte jetzt eine Device namens "sd*" (z.B. "sdb", "sdc" usw.) hinzugekommen sein. Sollten mehrere Devices hinzugekommen sein, die Karte wieder entfernen und ab Schritt 3 wiederholen.
  6. Im Terminal eingeben: "sudo dd if=/home/benutzername/Downloads/Pfad/Zum/Image.img of=/dev/sd*". Der Pfad nach "if=" und das "sd*" nach "of=/dev/" müssen natürlich angepasst werden! (VORSICHT: Alle Daten auf der Karte werden gelöscht)
  7. Warten bis der Befehl abgeschlossen ist
  8. SD-Karte in den Raspberry Pi einlegen

Die erste Inbetriebnahme

Jetzt da das Image fertig ist müsst ihr nur noch eine USB-Tastatur, eine USB-Maus, einen Bildschirm und das Powerkabel anschließen.
Optional kann das Raspberry Pi noch in das LAN eingebunden werden.
Nach einiger Zeit sollte der Bootprozess beendet sein und auf dem Bildschirm ein "raspberrypi login" erscheinen.

Der Standard Login bei Debian Squeeze Images lautet..
User: pi
Password: raspberry
Wichtig ist, dass die Keymap beim Raspberry Pi im Lieferzustand auf "uk" gesetzt ist. Dadurch sind unter anderem die Tastem "Z" und "Y" vertauscht.

Passwort ändern

Nach der Anmeldung solltet ihr das Passwort für den Benutzernamen "pi" ändern. Dies wird so gemacht:

$ passwd
  Das aktuelle Passwort
  Das neue Passwort
  Wiederholung vom neuen Passwort

Admin Account anlegen

Der nächste Schritt ist das anlegen eines Root-Accounts und die festlegung eines Root-Passwortes. Der Root-Account kann mit einem Administrator-Account unter Windows oder MAC OS gleichgesetzt werden. Er wird wie folgt angelegt:

$ sudo su 
  Neues Root-Passwort
  Wiederholung vom neuen Passwort

Keyboard Layout ändern (Debian "Squeeze")

Um das lästige Suchen der Sonderzeichen auf der UK Keymap zu vermeiden, sollte diese an die Tastatur angepaßt werden.

$ sudo nano /etc/default/keyboard

Der Ländercoder muß z.B. für ein deutsches Layout auf "de" gesetzt werden.
Sollte der Bootvorgang danach deutlich länger dauern, kann dies mit folgendem Befehl behoben werden.

$ sudo setupcon

Dies muß direkt in der Raspberry Pi Konsole erfolgen und funktioniert via SSH o.ä. nicht.

SSH-Server aktivieren (Debian "Squeeze")

Jetzt wird noch der SSH-Server vom Raspberry Pi aktiviert. Dadurch hat man die Möglichkeit das Raspberry Pi von einem anderen Rechner aus zu bedienen, solange sich beide Geräte in einem Netzwerk befinden. Dazu aber später mehr. Das SSH wird wie folgt aktiviert:

$ sudo mv /boot/boot_enable_ssh.rc /boot/boot.rc 

Anschließend wird das Raspberry Pi neu gebootet:

$ sudo shutdown -r now

Nach dem Neustart sollte vor dem "raspberrypi login" ein "starting OpenBSD Secure Shell Server: sshd" erscheinen. Dann ist der SSH-Server aktiviert und kann verwendet werden. Die IP-Adresse vom Raspberry Pi findet ihr so heraus:

$ ip addr

Das Raspberry Pi gibt nun folgendes zurück:

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
    link/ether b8:27:eb:ac:5e:2a brd ff:ff:ff:ff:ff:ff
    inet 192.168.178.25/24 brd 192.168.178.255 scope global eth0

Die IP-Adresse meines Boards lautet also "192.168.178.25".

Ändern von Hostname und IP (Debian "Squeeze")

Debian ist per default auf eine dynamische IP Zuweisung (DHCP) und auf den Hostname 'raspberrypi' konfiguriert.

Der Hostname kann über das Config-File '/etc/hostname' geändert werden.

$ sudo nano /etc/hostname

Soll das Raspberry Pi eine statische IP erhalten, so muss dies im Config-File '/etc/network/interfaces' geändert werden. Bei den Werkseinstellungen steht hier die folgende Zeile zur konfiguration auf DHCP.

iface eth0 inet dhcp

Diese muss wie folgt editiert werden.

iface eth0 inet static
     address 192.168.0.100
     network 192.168.0.0
     netmask 255.255.255.0
     broadcast 192.168.0.255
     gateway 192.168.0.1

Die Parameter sind dem eigenem Netzwerk anzupassen. Damit die Änderungen wirksam werden muß das Raspberry Pi neu gestartet werden.

$ sudo shutdown now -r

Jetzt können die neuen Einstellungen verifiziert werden.

$ ip addr
$ ping google.com

Fernzugriff auf das Raspberry Pi

Da nicht immer die Möglichkeit besteht das Raspberry Pi mit einem Monitor und einer Tastatur bzw. einer Maus zu verbinden (weil es z.B. irgendwo verbaut ist), haben wir SSH aktiviert. Nun wollen wir dies auch mal nutzen. Wir verbinden also unser Raspberry Pi mittels eines LAN-Hub, eines Routers oder direkt mit einem PC. Anschließend benötigen wir noch ein Programm welches SSH unterstützt. Ich verwende für Windows das Programm PuTTY. Das Programm wird gedownloadet und anschließend installiert. Unter Linux kann das Programm einfach über das Softwarecenter gedownloadet werden. Nach dem Öffnen sieht das Programm so aus:

Puttyq.jpg

Nun wird bei "Host Name" die IP-Adresse des Boards eingegeben (bei mir wäre dies 192.168.178.25). Als Port wird 22 (Standard für SSH) angegeben und bei "Connection type" wird der Haken bei "SSH" gesetzt. Als nächstes könnt ihr bei "Saved Sessions" noch einen Namen eingeben unter dem das Profil gespeichert wird und nach einem Klick auf "Save" wird das Profil gespeichert. Sobald ihr nun einen Doppelklick auf den Namen macht, öffnet sich ein Fenster und nach kurzer Zeit sollte dies hier erscheinen:

Putty2.jpg

Dort könnt ihr euch nun ganz normal anmelden. PuTTY verhält sich anschließend exakt genauso wie die Konsole direkt auf dem Raspberry Pi.

Falls ihr ein Linuxsystem verwenden, könnt ihr alternativ mit dem Befehl "ssh pi@xxx.xxx.xxx.xxx" auf das Raspberry Pi zugreifen. (x = IP-Adresse). Der Zugriff erfolgt dann ohne PuTTY.


Datentransfer mit dem Raspberry Pi

Nun wollen wir Dateien zwischen dem Raspberry Pi und unserem PC austauschen. Dies ermöglicht später einen Upload von fertig geschriebenen Programmen o.ä. Der Datenaustausch geschieht auch wieder über LAN, allerdings werden für Windows und Linux unterschiedliche Programme verwendet. Für Windows können Programme wie FileZilla oder Winscp verwendet werden.
Ich verwende aber lieber ein Linuxsystem da es später besser ist die Programme auf einem Linuxsystem zu kompilieren und anschließend zu übertragen. Aber darauf gehe ich später nochmal etwas genauer ein, wenn die ersten Programme geschrieben werden. Für die Leute die aber weiterhin Windows benutzen wollen, empfiehlt sich eine VM (z.B. Virtual Box).

Für den ersten Versuch erstellen wir uns ein einfaches Dokument mit dem Namen "Test.txt" auf dem Desktop. In dieses Dokument schreiben wir den Text "Hallo". Dieses Dokument wollen wir anschließend auf unser Raspberry Pi übertragen.

Via Konsole

Nun öffnen wir die Konsole und geben folgendes ein:

$ scp /home/daniel/Arbeitsfläche/Test.txt pi@192.168.178.25:
  Passwort

Das Kommando "SCP" setzt sich aus mehreren Parametern zusammen. Das erste Parameter ist der Pfad der Datei die wir kopieren wollen (in unserem Fall "Test.txt").
Den Pfad könnt ihr erfahren, indem ihr einen, wie bei Windows, einen Rechtsklick auf die Datei macht und anschließend auf "Eigenschaften" geht.
Der nächste Parameter ist der Name mit dem ihr euch beim Raspberry Pi anmelden wollt, gefolgt von einem @ und der IP-Adresse des Raspberry Pi.
Soll die Datei "Test.txt" an den Benutzer "xy" gesendet werden, lautet der Parameter xy@IP-Adresse. Das Passwort ist das Passwort des Accounts den ihr bei dem Befehl "SCP" angegeben habt. Nach dem Transfer sollte folgendes in der Konsole stehen:

Scpo.jpg

Schreibt ihr hingegen folgendes:

$ scp /home/daniel/Arbeitsfläche/Test.txt pi@192.168.178.25:abc/Text.txt
  Passwort

Dann wird die Datei auf dem Raspberry Pi in dem Ordner /home/pi/abc unter dem Namen "Text.txt" gespeichert. Wenn ihr den Parameter "abc/Text.txt" weglasst wird die Datei unter /home/pi gespeichert. Wird als Benutzername "xy" angegeben, befindet sich die Datei anschließend im Ordner /home/xy.
Nun überprüfen wir ob die Datei übertragen wurde. Dazu öffnen wir PuTTY und stellen eine Verbindung zum Raspberry Pi her.
Anschließend loggen wir uns ein und tippen folgendes in die Konsole:

$ cd /home/pi
$ ls

Mit dem Befehl "cd" wechseln wir in ein bestimmtes Verzeichnis (in dem Fall in das Verzeichnis "pi").
Dann werden alle Dateien mit dem Befehl "ls" aufgelistet die sich in dem Verzeichnis befinden zu dem wir gerade hingewechselt sind. Es sollte nun die Datei "Test.txt" angezeigt werden. Wenn wir nun folgendes eingeben:

$ cat Test.txt

Dann wird der Text, den wir vorhin in das Textdokument reingeschrieben haben, im Terminal angezeigt.
Um die Datei zu löschen schreiben wir einfach:

$ rm Test.txt

Via Nautilus

Eine weitere Möglichkeit Daten auszutauschen besteht darin, den Dateimanager eines Linuxbetriebssystems (z.B. Nautilus von Ubuntu) zu öffnen, dessen Adressleiste mit Strg+L in den Bearbeiten-Modus schalten und als Adresse "sftp://xxx.xxx.xxx.xxx" (x = IP-Adresse des Raspberry Pi) einzugeben. Dann nur noch die Anmeldedaten (Benutzername = pi, Passwort = raspberry) eingeben und schon kann man Datein beliebig hin- und herkopieren, erstellen, bearbeiten und löschen, wie man es eben von einem Dateimanager gewohnt ist.

Nautilus Pi SFTP.png

Speichergröße der SD-Karte widerherstellen (Debian "Squeeze")

Nun schauen wir uns die Speicherbelegung auf der SD-Karte etwas genauer an. Dazu stellen wir entweder eine SSH-Verbindung her oder wir machen es direkt am Raspberry Pi.
Um die aktuelle Speicherbelegung anzeigen zu lassen tippen wir folgendes ein:

$ df -h

Bei mir sieht diese so aus:

Filesystem            Size  Used Avail Use% Mounted on
/dev/mmcb1k0p2        1.6G  1.2G  5.5G  21% /
tmpfs                  94M     0   94M   0% /lib/init/rw
udev                   10M  152K  9.9M   2% /dev
tmpfs                  94M     0   94M   0% /dev/shm
/dev/mmcblk0p1         75M   29M   46M  39% /boot

Wie ihr seht, wird sich diese Liste sehr wahrscheinlich von der eigentlichen Speichergröße eurer SD-Karte unterscheiden.
Der Grund dafür ist relativ simpel. Das Debian-Image, welches ganz am Anfang aufgespielt wurde, ist für SD-Karten mit einer Speichergröße von 2GB ausgelegt.
Um uns das mal genauer anzuschauen geben wir folgendes ein:

$ sudo fdisk -l

Das Raspberry Pi gibt nun folgendes zurück:

/dev/mmcblk0p1              17        1216       76800    c  W95 FAT32 (LBA)
/dev/mmcblk0p2            1233       26672     1628160   83  Linux
/dev/mmcblk0p3           26689       29744      195584   82  Linux swap / Solaris

Die SD-Karte trägt unter Linux den Namen "mmcblk0". Weitere SD-Karten würde "mmcblk1" usw. heißen. Die einzelnen Partitionen auf der SD-Karte werden mit "p1", "p2", "p3", usw. abgekürzt.
Wie zu erkennen ist, besteht die SD-Karte aus drei Partitionen, wovon es sich bei einer Partition um eine FAT32 Partition (Partition "p1") handelt. Die anderen beiden sind Linux Partition (Partitionen "p2" und "p3").
Die FAT32 Partition ist die Partition, die für den Bootvorgang notwendig ist. Auf dieser Partition befindet sich u.a das Kernelimage.
Diese Partition sieht man übrigends auch wenn die Karte an einem Windowsrechner in ein Kartenleser gesteckt wird.
Da das Debian-Image nur für 2GB Karten gedacht ist, verwendet es auch nur 2GB der SD-Karte, egal wie groß eure Karte ist.
Da wir aber natürlich die gesamte SD-Karte nutzen wollen, müssen wir die Linux Partition "vergrößern".
Dafür löschen wir die gesamte Partition (die ja nur etwas um die 2GB groß ist) und erzeugen eine neue Partition. Diese Partition erstreckt sich anschließend über den gesamten Restspeicherplatz der SD-Karte.

´

VORSICHT!!!!
Wenn ihr hier einen Fehler macht, sind alle Daten futsch. Also lieber ein Back-Up eurer SD-Karte erstellen!

Die Formatierung wird nun wie folgt gestartet:

$ sudo fdisk -uc /dev/mmcblk0

Anschließend werdet ihr aufgefordert ein Kommando einzugeben. Als erstes lassen wir uns mit "p" die Partitionstabelle anzeigen.
Diese sieht anschließend so aus:

Disk /dev/mmcblk0: 7958 MB, 7958691840 bytes
4 heads, 32 sectors/track, 121440 cylinders, total 15544320 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x000ee283

        Device Boot      Start         End      Blocks   Id  System
/dev/mmcblk0p1            2048      155647       76800    c  W95 FAT32 (LBA)
/dev/mmcblk0p2          157696     3414015     1628160   83  Linux
/dev/mmcblk0p3         3416064     3807231      195584   82  Linux swap / Solaris

Jetzt müssen wir die Partitionen 2 und 3 löschen. Hierbei löschen wir NUR die Partitionen. Nicht aber die Daten.
Um eine Partition zu löschen geben wir den Befehl "d" ein und anschließend müsst ihr dann angeben welche Partition gelöscht werden soll.
Wir fangen mit Partition 2 an und dafür geben wir die Zahl "2" ein. Dasselbe machen wir für die Partition 3. Jetzt müssen wir eine neue Primärpartition erstellen. Dafür teilen wir dem Raspberry Pi mit dem Befehl "n" mit, dass wir eine neue Partition erstellen wollen. Anschließend erstellen wir mit dem Befehl "p" eine neue Primärpartition.
Diese Partition soll auch eine Nummer bekommen und da Partition 1 schon vorhanden ist (wir erinnern uns, dass Partition 1 die Bootpartition ist) nummerieren wir die Partition mit der Nummer "2".
Jetzt müssen wir die Größe der neuen Partition festlegen und diese dann erstellen. Dafür teilen wir dem Raspberry Pi als erstes den ersten Sektor der neuen Partition mit.
Wichtig ist das für den ersten Sektor NICHT der default-Wert genommen wird. Hier müsst ihr den Wert nehmen der weiter oben bei "/dev/mmcblk0" steht, sprich in diesem Beispiel 157696 (den Wert könnt ihr einfach aus der Liste rauskopieren.).
Bei dem letzten Sektor könnt ihr hingegen den default-Wert nehmen. Um diesen zu nehmen, reicht ein Druck auf "Enter" aus. Danach werdet ihr wieder aufgefordert einen Befehl einzugeben. Jetzt gebt ihr "w" ein.
Jetzt müsst ihr das Raspberry Pi mit diesem Befehl rebooten, damit die Änderungen übernommen werden und die Partition erstellt wird:

$ sudo reboot

Wenn ihr euch wieder eingeloggt habt, müsst ihr die Partition noch "formatieren". Dies geschieht mit folgendem Befehl:

$ sudo resize2fs /dev/mmcblk0p2

Die Zeit zum Ausführen dieses Befehls hängt von der Größe der SD-Karte ab, sprich bei großen Karten dauert dies um einiges länger! Nachdem dieser Befehl ausgeführt wurde, beinhaltet die neue Partition allen Speicher der noch keiner Partition zugeordnet war.
Wenn ihr anschließend

$ df -h

eingebt, sollte eure neue Speichertabelle so aussehen (dieses Beispiel gilt für eine 8GB Karte):

Filesystem            Size  Used Avail Use% Mounted on
/dev/mmcb1k0p2        7.3G  1.5G  5.5G  21% /
tmpfs                  94M     0   94M   0% /lib/init/rw
udev                   10M  152K  9.9M   2% /dev
tmpfs                  94M     0   94M   0% /dev/shm
/dev/mmcblk0p1         75M   29M   46M  39% /boot

Nun ist die Kartengröße erfolgreich wiederhergestellt und ihr könnt den kompletten Speicherplatz eurer Karte benutzen.

Erstellen einer Auslagerungsdatei

Da das Raspberry Pi nur einen sehr kleinen Arbeitsspeicher hat, zeige ich euch hier wie ihr eine Auslagerungsdatei erstellt.
Diese Datei unterstützt den Arbeitsspeicher etwas, indem dadurch der Arbeitsspeicher quasi "vergrößert" wird.
Als erstes wechseln wir mit

$ cd /var

in das Verzeichnis /var. Anschließend erstellen wir die Auslagerungsdatei. Dies geschieht mit dem Befehl:

$ sudo dd if=/dev/zero of=swapfile bs=1M count=128

Danach wird die Datei als Auslagerungsdatei eingerichtet.
Dafür verwenden wir folgenden Befehl:

$ sudo mkswap /var/swapfile

Anschließend wird die Auslagerungsdatei aktiviert:

$ sudo swapon /var/swapfile

Dieser Schritt dauert nun einen Augenblick. Damit die Auslagerungsdatei genutzt werden kann, muss diese in die "Filesystemtable" eingetragen werden.
Als erstes rufen wir diese mit folgendem Befehl auf:

$ nano /etc/fstab

Diese sollte dann etwa so aussehen:

proc            /proc   proc    defaults                        0 0
/dev/mmcblk0p1  /boot   vfat    defaults                        0 0
#/dev/mmcblk0p3  none    swap   sw                              0 0

Wie unschwer zu erkennen ist, steht die Partition 3 von "MMC0" noch als Swapfile drin.
Da diese Partition aber gelöscht wurde, muss dies korrigiert werden.
Dazu löscht ihr erstmal alles und anschließend könnt ihr mittels Copy & Paste diesen Text einfügen:

proc            /proc   proc    defaults                        0 0
/dev/mmcblk0p1  /boot   vfat    defaults                        0 0
/dev/mmcblk0p2  /       ext4    defaults,noatime,nodiratime     0 0
/var/swapfile   none    swap    sw                              0 0

Nun wird die vorher angelegte Datei namens "swapfile" auch als Auslagerungsdatei verwendet.
Mit "Strg + O" wird die Datei "fstab" anschließend gespeichert und mit "Strg + X" schließt ihr den Editor. Jetzt muss das System noch rebootet werden.
Nach dem reboot können wir alles nochmal kontrollieren. Dazu tippen wir als erstes

$ top

ein und dann sollte das hier angezeigt werden:

Swap:   131068k total,        0k used,   131068k free,    82376k cached

Nun ist die Auslagerungsdatei bereit und kann verwendet werden.

GPIO ansprechen

Via Shell

Via Programm (C, Python o.ä.)

Via Web

Anwendungen

Ansteuern der GPIO's

Informationen zu den GPIO Pins

Siehe auch

Weblinks

Roboternetz Forum zum Raspberry Pi
Raspberry Pi.org
Ubuntuuser Wiki
Debian Wiki
Tutorial zu den IOs
Größe der SD-Karte anpassen
Programmbeispiele ( in C )

--Kampi 18:20, 5. Jul 2012 (CEST)