Embedded Linux mit Raspberry Pi und Co.

Name: Embedded Linux mit Raspberry Pi und Co.
Brand: MITP
Price: 9.99 EUR
Availability: OnlineOnly

Ralf Jesse(Autor*in)

MITP (Verlag)

1. Auflage

Erschienen am 29. Januar 2016

408 Seiten

E-Book

ePUB ohne DRM

Systemvoraussetzungen

E-Book

PDF ohne DRM

Systemvoraussetzungen

978-3-95845-063-9 (ISBN)

9,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB ohne DRM und PDF ohne DRM

(Hinweis: Die Auswahl des von Ihnen gewünschten Dateiformats und des Kopierschutzes erfolgt erst im System des E-Book Anbieters)

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Embedded-Linux-Kernel erzeugen
Treiber und Kernelmodule entwickeln
Praxisbeispiele mit LED-Matrix und LC-Displays

Raspberry Pi, BeagleBone Black, CubieBoard und Co. haben dazu beigetragen, das Interesse an Embedded Linux sowie dessen Programmierung und Nutzung für alltägliche Dinge zu wecken. Es wird verstärkt immer mehr auch im industriellen Umfeld eingesetzt. Dieses Buch vermittelt die Grundlagen, die für den produktiven Einsatz von Embedded Linux notwendig sind.
Ralf Jesse führt am Beispiel des beliebten Minicomputers Raspberry Pi in die Handhabung und Weiterentwicklung von Embedded Linux ein. Er behandelt alle Schritte, die für die Entwicklung von Embedded-Linux-Systemen wichtig sind:
Aufsetzen und Nutzen einer sogenannten Cross-Development-Plattform auf der Basis eines in einer virtuellen Maschine ausgeführten Desktop Linux
Übertragen der entwickelten Software auf das Zielsystem
Grundlagen von Shellscripts für komfortablere Softwareentwicklung
Vermittlung der für den Bau eines Kernels und des root-Dateisystems benötigten Kenntnisse
Einfaches Starten und Testen des Kernels unter Einsatz des Bootmanagers "Das U-Boot"
instieg in die Entwicklung von Gerätetreibern und Kernelmodulen
Das Buch richtet sich an alle, die "mehr" aus ihrem Embedded System herausholen wollen. Die dafür erforderlichen Linux-Kenntnisse sind keine Voraussetzung, sondern werden im Buch erarbeitet.
Alternative Ansätze auf der Basis anderer Minicomputer werden ebenfalls aufgezeigt. Somit ist das Buch für alle relevant, die Embedded Linux als Betriebssystem einsetzen wollen, unabhängig von der verwendeten Hardware.

Aus dem Inhalt:
Linux-Grundlagen
Shell-Programmierung
Netzwerkanbindung
Aufbau einer Cross-Entwicklungsumgebung
Erstellen eines Embedded-Linux-Kernels
Erzeugen eines root-Dateisystems
Der Bootprozess für verschiedene Embedded PCs: Raspberry Pi, BeagleBone Black und Cubieboard
Einstieg in die Entwicklung von Treibern und Kernelmodulen
Template für eigene Treiber
Ansteuerung von Hardware
Praxisbeispiele: Schieberegister, Ansteuerung von 8x8-LED-Matrizen, Steuerung von textbasierten LC-Displays

Rezensionen / Stimmen

"Der Autor beginnt kurz mit den Grundlagen der Installation und des Datentausches zwischen Host und Embedded System und kommt dann gestützt auf Praxisbeispiele zum Bau eines Kernels und zu Grundlagen der Treiberentwicklung. Gute Informationsquelle; jedes Kapitel mit einer Übersicht weiterführender Literatur."
ekz Bibliotheksservice, 06/2016

Weitere Details

Weitere Ausgaben

Person

Inhalt

1 - Cover [Seite 1]
2 - Impressum [Seite 4]
3 - Inhaltsverzeichnis [Seite 5]
4 - Einleitung [Seite 11]
5 - Teil I: Einführung und Einrichtung einer Entwicklungsumgebung [Seite 17]
5.1 - Kapitel 1: Embedded Linux [Seite 19]
5.1.1 - 1.1 Desktop-Betriebssysteme [Seite 19]
5.1.2 - 1.2 Bare-Metal vs. Betriebssystem [Seite 20]
5.1.2.1 - 1.2.1 Mikroprozessoren vs. Mikrocontroller [Seite 21]
5.1.3 - 1.3 Embedded Betriebssysteme [Seite 22]
5.1.4 - 1.4 Die Architektur von Linux [Seite 23]
5.1.4.1 - 1.4.1 Erläuterungen [Seite 23]
5.1.5 - 1.5 Beliebte Linux-Distributionen [Seite 27]
5.1.6 - 1.6 Linux installieren [Seite 29]
5.1.6.1 - 1.6.1 Parallele Installation von Linux Mint zum vorhandenen Betriebssystem [Seite 30]
5.1.6.2 - 1.6.2 Installation von Linux Mint in VirtualBox [Seite 32]
5.1.7 - 1.7 Erfahrungen Linux Mint + VirtualBox [Seite 39]
5.1.7.1 - 1.7.1 Größe der virtuellen Festplatte ändern [Seite 39]
5.1.7.2 - 1.7.2 Zielpartition für VirtualBox festlegen [Seite 40]
5.1.7.3 - 1.7.3 Umziehen der virtuellen Maschine [Seite 40]
5.1.7.4 - 1.7.4 Nicht genügend Arbeitsspeicher [Seite 42]
5.1.8 - 1.8 Weiterführende Literatur [Seite 42]
5.2 - Kapitel 2: Netzwerkanbindung [Seite 43]
5.2.1 - 2.1 Datenaustausch zwischen Host und Embedded System [Seite 43]
5.2.1.1 - 2.1.1 Samba [Seite 43]
5.2.1.2 - 2.1.2 FileZilla [Seite 52]
5.2.1.3 - 2.1.3 Daten austauschen mit scp [Seite 55]
5.2.2 - 2.2 Verzeichnisstruktur von Linux/Raspbian [Seite 60]
5.2.2.1 - 2.2.1 /bin [Seite 61]
5.2.2.2 - 2.2.2 /boot [Seite 62]
5.2.2.3 - 2.2.3 /dev [Seite 62]
5.2.2.4 - 2.2.4 /etc [Seite 63]
5.2.2.5 - 2.2.5 /home [Seite 63]
5.2.2.6 - 2.2.6 /lib [Seite 64]
5.2.2.7 - 2.2.7 /lost+found [Seite 65]
5.2.2.8 - 2.2.8 /media [Seite 65]
5.2.2.9 - 2.2.9 /mnt [Seite 65]
5.2.2.10 - 2.2.10 /opt [Seite 65]
5.2.2.11 - 2.2.11 /proc [Seite 65]
5.2.2.12 - 2.2.12 /root [Seite 66]
5.2.2.13 - 2.2.13 /run [Seite 67]
5.2.2.14 - 2.2.14 /sbin [Seite 67]
5.2.2.15 - 2.2.15 /selinux [Seite 67]
5.2.2.16 - 2.2.16 /srv [Seite 67]
5.2.2.17 - 2.2.17 /sys [Seite 67]
5.2.2.18 - 2.2.18 /tmp [Seite 67]
5.2.2.19 - 2.2.19 /usr [Seite 67]
5.2.2.20 - 2.2.20 /var [Seite 68]
5.2.3 - 2.3 Neue Benutzer und Gruppen einrichten [Seite 68]
5.2.3.1 - 2.3.1 Einen User hinzufügen bzw. entfernen [Seite 68]
5.2.3.2 - 2.3.2 Gruppen hinzufügen bzw. entfernen [Seite 69]
5.2.4 - 2.4 Weiterführende Literatur [Seite 69]
5.3 - Kapitel 3: Shell-Programmierung [Seite 71]
5.3.1 - 3.1 Erste Schritte [Seite 72]
5.3.1.1 - 3.1.1 Die Kommandos »man« und »info« [Seite 72]
5.3.2 - 3.2 Geschichte der Shells [Seite 73]
5.3.3 - 3.3 Die Bourne-again-Shell - bash [Seite 73]
5.3.3.1 - 3.3.1 Ein- und Ausgabeumleitung [Seite 74]
5.3.3.2 - 3.3.2 Shell-Variablen [Seite 78]
5.3.3.3 - 3.3.3 Kommentare [Seite 85]
5.3.3.4 - 3.3.4 Systemkommandos in Shellscripts [Seite 85]
5.3.3.5 - 3.3.5 Mehrere Kommandos in einer Zeile [Seite 87]
5.3.3.6 - 3.3.6 Bedingungen/Vergleiche [Seite 88]
5.3.3.7 - 3.3.7 Funktionen in Shellscripts [Seite 92]
5.3.3.8 - 3.3.8 Schleifen [Seite 102]
5.3.3.9 - 3.3.9 Professionelle Übergabe von Argumenten [Seite 106]
5.3.3.10 - 3.3.10 Einschränkungen bei Shellscripts [Seite 111]
5.3.4 - 3.4 Weiterführende Literatur [Seite 112]
5.4 - Kapitel 4: Cross-Toolchains [Seite 113]
5.4.1 - 4.1 Cross-Toolchains für Raspberry Pi B+ [Seite 113]
5.4.1.1 - 4.1.1 Toolchain und IDE für Windows [Seite 115]
5.4.1.2 - 4.1.2 Toolchain und IDE für Linux (Mint) [Seite 116]
5.4.1.3 - 4.1.3 Toolchain und IDE für Mac OS X [Seite 118]
5.4.2 - 4.2 Die Bibliothek wiringPi [Seite 118]
5.4.2.1 - 4.2.1 Herunterladen von wiringPi [Seite 119]
5.4.2.2 - 4.2.2 wiringPi »bauen« [Seite 120]
5.4.2.3 - 4.2.3 Funktionen in wiringPi [Seite 121]
5.4.2.4 - 4.2.4 Weitere Informationen zu wiringPi [Seite 121]
5.4.2.5 - 4.2.5 Anschlussbelegung des Raspberry Pi B+ [Seite 122]
5.4.3 - 4.3 Konfiguration von Code::Blocks [Seite 123]
5.4.3.1 - 4.3.1 Auswahl des Compilers [Seite 124]
5.4.3.2 - 4.3.2 Einstellen der Compiler-Optionen [Seite 124]
5.4.3.3 - 4.3.3 Bibliothek(en) hinzufügen [Seite 125]
5.4.3.4 - 4.3.4 Erweitern des Suchpfades [Seite 126]
5.4.3.5 - 4.3.5 Toolchain executables [Seite 127]
5.4.3.6 - 4.3.6 Testen der Toolchain [Seite 128]
5.4.4 - 4.4 crosstool-ng [Seite 134]
5.4.4.1 - 4.4.1 Vorarbeiten [Seite 135]
5.4.4.2 - 4.4.2 Erstellen und installieren von crosstool-ng [Seite 136]
5.4.4.3 - 4.4.3 Toolchain konfigurieren [Seite 137]
5.4.5 - 4.5 Weiterführende Literatur [Seite 141]
6 - Teil II: Techniken zur Programmierung von Kernel und rootfs [Seite 143]
6.1 - Kapitel 5: Raspbian - der Kernel [Seite 145]
6.1.1 - 5.1 Überblick [Seite 146]
6.1.1.1 - 5.1.1 Einmalig durchzuführende Schritte [Seite 146]
6.1.1.2 - 5.1.2 Zu wiederholende Schritte [Seite 146]
6.1.2 - 5.2 Kernel erzeugen - detaillierte Anleitung [Seite 147]
6.1.2.1 - 5.2.1 Einmalig durchzuführende Schritte - Details [Seite 147]
6.1.2.2 - 5.2.2 Zu wiederholende Schritte [Seite 151]
6.1.3 - 5.3 Das Shellscript mkrpi [Seite 166]
6.1.3.1 - 5.3.1 mkrpi - das Listing zum Shellscript [Seite 167]
6.1.3.2 - 5.3.2 Funktion und Anwendung von mkrpi [Seite 175]
6.1.4 - 5.4 Weiterführende Literatur [Seite 180]
6.2 - Kapitel 6: Das root-Dateisystem - rootfs [Seite 181]
6.2.1 - 6.1 rootfs erzeugen [Seite 182]
6.2.1.1 - 6.1.1 Benötigte Software [Seite 183]
6.2.1.2 - 6.1.2 Die nächsten Schritte [Seite 185]
6.2.1.3 - 6.1.3 Imagedatei erzeugen [Seite 198]
6.2.1.4 - 6.1.4 Schreiben der Boot-Partition [Seite 203]
6.2.1.5 - 6.1.5 Schreiben des root-Dateisystems [Seite 205]
6.2.1.6 - 6.1.6 Das Ende naht ... [Seite 206]
6.2.2 - 6.2 Alternative Methode [Seite 207]
6.2.2.1 - 6.2.1 Beschaffung und Anwendung von Buildroot [Seite 208]
6.2.3 - 6.3 Weiterführende Literatur [Seite 215]
6.3 - Kapitel 7: Der Bootprozess [Seite 217]
6.3.1 - 7.1 Bare-Metal-Systeme [Seite 217]
6.3.2 - 7.2 Geräte mit Betriebssystem [Seite 218]
6.3.2.1 - 7.2.1 Der Bootprozess des Raspberry Pi [Seite 218]
6.3.2.2 - 7.2.2 Der Bootprozess beim BeagleBone Black BBB [Seite 219]
6.3.2.3 - 7.2.3 Der Bootprozess beim Cubieboard [Seite 219]
6.3.3 - 7.3 Allgemeine Beschreibung des Bootvorgangs [Seite 220]
6.3.3.1 - 7.3.1 Bootloader [Seite 220]
6.3.3.2 - 7.3.2 Die Aufgabe von Bootloadern [Seite 221]
6.3.4 - 7.4 Das U-Boot und der Raspberry Pi [Seite 224]
6.3.4.1 - 7.4.1 Sourcecode von »Das U-Boot« [Seite 224]
6.3.5 - 7.5 Weiterführende Literatur [Seite 241]
7 - Teil III: Grundlagen der Treiberentwicklung [Seite 243]
7.1 - Kapitel 8: Treiber und Module I [Seite 245]
7.1.1 - 8.1 Auffrischung [Seite 246]
7.1.2 - 8.2 »Normale« Dateien und Gerätedateien [Seite 247]
7.1.2.1 - 8.2.1 Schnittstellen zwischen User Space und Kernel [Seite 248]
7.1.2.2 - 8.2.2 Schnittstellen zwischen Kernel und Hardware [Seite 249]
7.1.2.3 - 8.2.3 Wichtige Programme im User Space [Seite 251]
7.1.3 - 8.3 Weitere Voraussetzungen [Seite 255]
7.1.4 - 8.4 Das erste Kernelmodul [Seite 256]
7.1.4.1 - 8.4.1 Quelltext des Moduls und Makefile [Seite 257]
7.1.4.2 - 8.4.2 Kompilieren des Moduls [Seite 258]
7.1.4.3 - 8.4.3 Modul testen [Seite 258]
7.1.4.4 - 8.4.4 Details zu nix.c/nix.ko [Seite 261]
7.1.4.5 - 8.4.5 kbuild [Seite 261]
7.1.5 - 8.5 Ein weiteres einfaches Kernelmodul [Seite 263]
7.1.5.1 - 8.5.1 Der Sourcecode [Seite 263]
7.1.5.2 - 8.5.2 Log-Level [Seite 265]
7.1.5.3 - 8.5.3 Kernelmodul ausprobieren [Seite 265]
7.1.6 - 8.6 Moderne Variante von hellodriver [Seite 266]
7.1.6.1 - 8.6.1 Moderne Variante des hellodriver-Moduls [Seite 267]
7.1.7 - 8.7 Ende der Einführung [Seite 268]
7.1.8 - 8.8 Weiterführende Literatur [Seite 269]
7.2 - Kapitel 9: Treiber und Module II [Seite 271]
7.2.1 - 9.1 Auf dem Weg zu einem richtigen Gerät [Seite 271]
7.2.1.1 - 9.1.1 Funktionen, Makros, Datentypen [Seite 271]
7.2.1.2 - 9.1.2 Der Sourcecode [Seite 279]
7.2.2 - 9.2 Weiterführende Literatur [Seite 290]
7.3 - Kapitel 10: Treiber und Module III [Seite 291]
7.3.1 - 10.1 Checkliste für die Treiberentwicklung [Seite 291]
7.3.1.1 - 10.1.1 Headerdateien [Seite 291]
7.3.1.2 - 10.1.2 Die Struktur file_operations [Seite 292]
7.3.1.3 - 10.1.3 Initialisierung eines Treibers/Moduls [Seite 293]
7.3.1.4 - 10.1.4 Entfernen von Treibern/Modulen [Seite 295]
7.3.1.5 - 10.1.5 Funktion mydevice_open [Seite 296]
7.3.1.6 - 10.1.6 Funktion mydevice_close [Seite 297]
7.3.1.7 - 10.1.7 Schreiben und Lesen [Seite 298]
7.3.1.8 - 10.1.8 The End [Seite 300]
7.3.1.9 - 10.1.9 Generelle Erklärung einiger Funktionen [Seite 301]
7.3.2 - 10.2 Ansteuerung »echter« Hardware [Seite 303]
7.3.2.1 - 10.2.1 GPIO-Funktionen [Seite 304]
7.3.2.2 - 10.2.2 GPIOs anwenden [Seite 306]
7.3.2.3 - 10.2.3 (Mögliche) Erweiterung des Treibers [Seite 310]
7.3.3 - 10.3 Weiterführende Literatur [Seite 312]
8 - Teil IV: Treiberentwicklung in der Praxis [Seite 313]
8.1 - Kapitel 11: Praxis I [Seite 315]
8.1.1 - 11.1 Das serielle Schieberegister SN74HC595 [Seite 315]
8.2 - Kapitel 12: Praxis II [Seite 329]
8.2.1 - 12.1 Der Baustein Maxim 7219 [Seite 329]
8.2.1.1 - 12.1.1 Beschreibung des Maxim 7219 [Seite 330]
8.2.1.2 - 12.1.2 Zeitverhalten bei der Ansteuerung [Seite 331]
8.2.1.3 - 12.1.3 Kaskadieren mehrerer Maxim 7219/7221 [Seite 332]
8.2.2 - 12.2 Ansteuerung einer 8 x 8-LED-Matrix [Seite 333]
8.2.2.1 - 12.2.1 Der Schaltplan [Seite 333]
8.2.3 - 12.3 Die Treibersoftware [Seite 335]
8.2.3.1 - 12.3.1 Das Makefile [Seite 336]
8.2.3.2 - 12.3.2 Die Headerdatei max7219.h [Seite 337]
8.2.3.3 - 12.3.3 Der C-Sourcecode max7219imp.c [Seite 338]
8.2.3.4 - 12.3.4 Das Testprogramm für den Treiber [Seite 346]
8.2.3.5 - 12.3.5 Verbesserungsvorschläge [Seite 351]
8.2.4 - 12.4 Ansteuerung von 7-Segment-Anzeigen [Seite 352]
8.3 - Kapitel 13: Praxis III [Seite 353]
8.3.1 - 13.1 Der HD44780 - Aus dem Datenblatt [Seite 353]
8.3.2 - 13.2 Die Hardware [Seite 355]
8.3.3 - 13.3 Die Headerdatei hd44780.h [Seite 356]
8.3.3.1 - 13.3.1 Einige Erläuterungen [Seite 359]
8.3.4 - 13.4 Der Treiber hd44780.c [Seite 361]
8.3.4.1 - 13.4.1 Erläuterung des Programms [Seite 371]
8.3.5 - 13.5 Das Testprogramm im User Space [Seite 375]
8.3.6 - 13.6 Weiterführende Literatur [Seite 380]
8.4 - Anhang A: Literaturverzeichnis [Seite 381]
8.4.1 - A.1 Embedded Systeme, Architektur etc. [Seite 381]
8.4.2 - A.2 VirtualBox [Seite 381]
8.4.3 - A.3 Samba [Seite 381]
8.4.4 - A.4 Shell-Programmierung [Seite 381]
8.4.5 - A.5 Toolchains und Bibliotheken [Seite 382]
8.4.6 - A.6 Bootstrapping, Buildroot etc. [Seite 382]
8.4.7 - A.7 Der Bootprozess [Seite 382]
8.4.8 - A.8 Pointer und Strukturen in C [Seite 382]
8.4.9 - A.9 Das Kernel-Buildsystem und Treiber [Seite 382]
8.4.10 - A.10 Bücher [Seite 383]
8.5 - Anhang B: Belegung der GPIO-Ports [Seite 385]
8.5.1 - B.1 GPIO-Belegung gemäß wiringPi [Seite 385]
8.5.2 - B.2 GPIO-Belegung gemäß Broadcom [Seite 386]
8.6 - Anhang C: Safety und Security [Seite 387]
8.6.1 - C.1 Security [Seite 387]
8.6.2 - C.2 Safety [Seite 388]
8.6.2.1 - C.2.1 Maßnahmen in der Automobilindustrie [Seite 388]
8.6.2.2 - C.2.2 Umsetzung in der Programmierung [Seite 389]
8.6.3 - C.3 Ergänzende Literatur [Seite 390]
8.7 - Anhang D: Kopieren mit scp [Seite 391]
8.8 - Anhang E: Code::Blocks [Seite 393]
8.8.1 - E.1 Projekteinstellungen [Seite 393]
8.8.1.1 - E.1.1 Properties [Seite 394]
8.8.1.2 - E.1.2 Build options ... [Seite 395]
9 - Stichwortverzeichnis [Seite 397]

Einleitung

Embedded Linux? hat nicht zuletzt durch die Artikel in Spiegel Online (2012) und Focus Online (2013) einen sehr hohen Bekanntheitsgrad erlangt. Dass Embedded Linux Programmierern, »Makern« und professionellen Hard- und Softwareentwicklern bereits bekannt war, kann man getrost voraussetzen. Anders ist dies bei »normalen« Anwendern: Dass die Hersteller aktueller Blueray-Disk-Player oder des neuen Smart-TV sowie von Wasch- und Geschirrspülmaschinen oder Wäschetrocknern Embedded Linux sehr häufig für die Steuerung der Elektronik und die Benutzerführung einsetzen, war der Allgemeinheit vor Erscheinen dieser Artikel vermutlich nicht geläufig. Dass Android, das Betriebssystem für Smartphones, ebenfalls einen (Embedded-)Linux-Kern hat, war vielen Anwendern wahrscheinlich ebenfalls unbekannt.

Die sehr beliebten Mini-Computer Raspberry Pi?, BeagleBone Black? und »Kollegen« haben dazu beigetragen, das Interesse an den Grundlagen von Embedded Linux sowie dessen Programmierung und Nutzung für alltägliche Dinge zu wecken, wie die Steuerung von Markisen und der Wohnraum-Beleuchtung oder die Regelung von Heizungsanlagen während der Abwesenheit: Viele Anwender, die früher nicht daran gedacht haben, sich mit diesem - zugegebenermaßen - komplexen Thema zu befassen, haben in dieser Beschäftigung ein interessantes Hobby und möglicherweise den Einstieg in eine neue berufliche Herausforderung gefunden.

Dieses Buch soll Ihnen unter Einsatz des Raspberry Pi den Einstieg in die Welt von Embedded Linux ebnen. Da die vermittelten Grundlagen allgemeingültig sind, können Sie die Erkenntnisse ebenfalls auf andere Embedded PCs übertragen. Sie werden erfahren, wie Sie eine Cross-Entwicklungsumgebung aufsetzen, wie Sie Daten zwischen dem Entwicklungs-PC und dem Zielgerät (dem Embedded PC) austauschen, wie Sie den Entwicklungsaufwand durch den Einsatz von »Das U-Boot« weiter reduzieren und optimieren können, und Sie lernen den Einstieg in die Treiberprogrammierung kennen. Ein vereinfachter Einstieg in die Shellprogrammierung zeigt Ihnen die Nutzung der wichtigsten Systemkommandos, sodass Sie in die Lage versetzt werden, eigene Shellscripts zu entwickeln bzw. bereits vorhandenes Wissen aufzufrischen. Das Ende jedes Kapitels umfasst eine Übersicht über ausgewählte weiterführende Literatur zum behandelten Stoff, sodass Sie die erworbenen Kenntnisse problemlos entsprechend Ihren eigenen Wünschen und Vorstellungen vertiefen können.

Als zwingend werden mittlere bis gute Kenntnisse der Programmiersprache C und der englischen Sprache vorausgesetzt. Die Gründe hierfür sind, dass der Kernel von Embedded Linux zu einem bedeutenden Teil in dieser Programmiersprache geschrieben wurde und wesentliche weiterführende Literatur - auch in Form von Datenblättern - nur in englischer Sprache verfügbar ist. Ebenfalls vorausgesetzt wird, dass Sie wissen, wie Ihr Mini-Computer in Betrieb genommen wird: Informationen zur Beschaffung und Installation des Betriebssystems vermittelt dieses Buch nicht!

Besondere Kenntnisse der Elektronik werden nicht vorausgesetzt, obwohl gewisse Grundlagen hier sehr hilfreich sind! Sie werden später beispielsweise Leuchtdioden sowohl direkt (Kapitel 4) als auch unter Einsatz von Schieberegistern ansteuern (Teil IV, Praxisteil I): Dass ohmsche Widerstände den elektrischen Strom begrenzen und somit eine Überlastung der GPIO-Leitungen oder hieran angeschlossener elektronischer Komponenten vermeiden, sollte als Basiswissen vorhanden sein.

Zielgruppe dieses Buches

Dieses Buch richtet sich an alle, die »mehr« aus ihrem Embedded System herausholen wollen. Diese Gruppe umfasst mit Ausnahme »echter« Linux-Profis alle Anwender vom Hobbyisten und interessierten Laien über Studenten aller technischen Fachrichtungen bis hin zu denjenigen, die ihr Geld mit der Programmierung von Computern oder der Entwicklung elektronischer Schaltungen verdienen, sich aber bisher noch nicht vertiefend mit Linux oder Embedded Linux beschäftigt haben.

An der Definition der Zielgruppe für dieses Buch erkennen Sie, dass Linux-Kenntnisse nicht erforderlich sind: Die erforderlichen Grundlagen für einen erfolgreichen Einsatz sowie für die Einarbeitung in vertiefende Aspekte werden in diesem Buch erarbeitet.

Das Buch ist in vier Teile gegliedert, von denen der erste Teil einen »sanften« Einstieg in die Embedded-Linux-Welt darstellt.

Teil I

In Kapitel 1 werden Sie den Unterschied zwischen sogenannten Bare-Metal-Mikrocontroller-Systemen und Mikrocontroller-Systemen mit Betriebssystem sowie den Unterschied zwischen dem Kernel »Linux« und Linux-Distributionen kennenlernen. Sie erfahren hier auch den Unterschied zwischen Mikroprozessoren und Mikrocontrollern. Im Anschluss erhalten Sie - ebenfalls noch in Kapitel 1 - einen Überblick über die grundlegende Architektur von Linux und Embedded Linux. Den Abschluss von Kapitel 1 bildet eine Beschreibung der Parallelinstallation von Linux Mint zu einem bereits vorhandenen Windows-Betriebssystem bzw. der Installation von Linux Mint in einer virtuellen Maschine. Die Durchführung einer dieser Varianten ist sehr empfehlenswert, da die »Rechenpower« des Raspberry Pi im Vergleich zu Standard-PCs - gelinde gesagt - unterdurchschnittlich ist: Wenn es später im Buch darum geht, einen eigenen Kernel zu entwickeln, werden Sie die Vorteile des sogenannten Cross-Developments zu schätzen wissen.

Kapitel 2 befasst sich im ersten Schritt mit der Installation und der Basiskonfiguration von Samba. Hierdurch lässt sich der Mini-Computer in ein bereits vorhandenes (Heim-)Netzwerk integrieren. Dies ist nicht immer erwünscht oder erforderlich. Es muss dann aber eine andere Möglichkeit vorhanden sein, um die Software vom Host auf das Target zu übertragen und dort zu testen. Für diese Anforderung liefert Kapitel 2 ebenfalls eine Antwort. Der überwiegende Teil von Kapitel 2 beschreibt die Verzeichnisstruktur eines typischen Unix- oder Linux-Betriebssystems, also auch die eines Embedded Linux.

In Kapitel 3 steht die Programmierung der Shell im Vordergrund. Die Shell ist ein wesentlicher Aspekt für die Beherrschung von Linux/Embedded Linux. Steht auf einem Desktop-Linux in der Regel eine grafische Benutzeroberfläche auch für die Systemverwaltung zur Verfügung, so existiert diese Möglichkeit auf Embedded-Systemen in der Regel aufgrund der stark eingeschränkten Ressourcen (CPU-Taktung, Mangel an Arbeitsspeicher, Festplattenspeicher etc.) nicht. Dieses Kapitel liefert eine grundlegende Einführung in die wichtigsten Aspekte der Shell-Programmierung.

Bevor der Einstieg in die Shell-Programmierung erfolgt, werden aber zunächst die Programme man und info vorgestellt, da sie sehr ausführliche Informationen zu den einzelnen Kommandos zur Verfügung stellen. Darüber hinaus geht es vorher um die Ein- und Ausgabeumlenkung. Im Anschluss werden dann aber endlich die wichtigsten Features zum Einsatz der bash beschrieben. Hierzu zählen Shell-Variablen, die Programmierung von Alternativen (if-then-elif-else-fi sowie case-esac) bzw. Abfragen sowie die Programmierung von Schleifen.

Kapitel 4 beschreibt den Aufbau einer Cross-Entwicklungsumgebung für Software, die später auf dem Embedded PC ausgeführt werden soll. Ich habe mich hier für Code::Blocks entschieden, einer integrierten Entwicklungsumgebung, die für Windows-, Linux- und Mac-OS-X-Systeme verfügbar ist. Der besondere Charme dieser Entwicklungsumgebung liegt darin, dass sie vollständig in der Programmiersprache C++ geschrieben wurde, sodass die Abhängigkeit von weiterer Software entfällt, wie einer Java-Laufzeitumgebung: Durch die Installation von systemspezifischer Software, die grundsätzlich immer für die Softwareentwicklung benötigt wird, sind alle Abhängigkeiten automatisch erfüllt. Der Brite Gordon Henderson hat für den Raspberry Pi die Bibliothek wiringPi entwickelt und als Open-Source-Software der Community zur Verfügung gestellt. Kapitel 4 beschreibt die Beschaffung dieser Bibliothek und bietet darüber hinaus einen ersten Einstieg in ihre Nutzung.

Teil II

Kapitel 5 beschreibt, wie Sie einen eigenen Embedded-Linux-Kernel bauen und in Betrieb nehmen. Hierbei handelt es sich um einen Standardkernel ohne weitere Modifikationen. Wenn Sie zu einem späteren Zeitpunkt einen eigenen Kernel entwickeln wollen, so zeigt Ihnen dieses Kapitel, worauf Sie zu achten haben. Diese Beschreibung liegt in einer Schritt-für-Schritt-Form vor, sodass Sie sie auch als eine Art Checkliste betrachten können. Dass auch Alternativen für die meisten der erforderlichen Schritte erläutert werden, erweitert den Horizont und zeigt, dass im Regelfall immer mehrere Varianten zum gewünschten Ergebnis führen.

In Kapitel 6 wird gezeigt, wie Sie ein root-Dateisystem von Hand erzeugen können. Mit dem Wissen aus Kapitel 3, dem Verstehen des Shellscripts mkrpi aus Kapitel 5 sowie der in diesem Kapitel beschriebenen Vorgehensweise sollten Sie in der Lage sein, die hier durchgeführten Schritte selbst mit einem Shellscript zu automatisieren. Der Fokus liegt hierbei auf dem...

Inhalt (1) (PDF) Inhalt (2) (EPUB)

Systemvoraussetzungen

Als PDF speichern Als Link merken