Embedded Linux mit Raspberry Pi und Co.

Autor	Ralf Jesse
Verlag	mitp Verlags GmbH & Co. KG
Erscheinungsjahr	2016
Reihe	mitp Professional
Seitenanzahl	408 Seiten
ISBN	9783958450622
Format	ePUB/PDF
Kopierschutz	kein Kopierschutz/DRM
Geräte	PC/MAC/eReader/Tablet
Preis	9,99 EUR

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

Ralf Jesse ist Diplom-Ingenieur der Elektrotechnik mit mehr als 25 Jahren beruflicher Praxis im Einsatz von Mikroprozessoren und -controllern. Nach ersten Erfahrungen als Entwicklungsingenieur in einem Maschinenbau-Unternehmen folgten mehr als 20 Jahre als Software-Ingenieur in einem großen japanischen Konzern.

Kaufen Sie hier:

Horizontale Tabs

Leseprobe

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...

Blick ins Buch

Inhaltsverzeichnis

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