O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Embedded Linux mit Raspberry Pi und Co.

Book Description

  • 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

Table of Contents

  1. Impressum
  2. Einleitung
  3. Teil I: Einführung und Einrichtung einer Entwicklungsumgebung
  4. Kapitel 1: Embedded Linux
    1. 1.1 Desktop-Betriebssysteme
    2. 1.2 Bare-Metal vs. Betriebssystem
      1. 1.2.1 Mikroprozessoren vs. Mikrocontroller
    3. 1.3 Embedded Betriebssysteme
    4. 1.4 Die Architektur von Linux
      1. 1.4.1 Erläuterungen
    5. 1.5 Beliebte Linux-Distributionen
    6. 1.6 Linux installieren
      1. 1.6.1 Parallele Installation von Linux Mint zum vorhandenen Betriebssystem
      2. 1.6.2 Installation von Linux Mint in VirtualBox
    7. 1.7 Erfahrungen Linux Mint + VirtualBox
      1. 1.7.1 Größe der virtuellen Festplatte ändern
      2. 1.7.2 Zielpartition für VirtualBox festlegen
      3. 1.7.3 Umziehen der virtuellen Maschine
      4. 1.7.4 Nicht genügend Arbeitsspeicher
    8. 1.8 Weiterführende Literatur
  5. Kapitel 2: Netzwerkanbindung
    1. 2.1 Datenaustausch zwischen Host und Embedded System
      1. 2.1.1 Samba
      2. 2.1.2 FileZilla
      3. 2.1.3 Daten austauschen mit scp
    2. 2.2 Verzeichnisstruktur von Linux/Raspbian
      1. 2.2.1 /bin
      2. 2.2.2 /boot
      3. 2.2.3 /dev
      4. 2.2.4 /etc
      5. 2.2.5 /home
      6. 2.2.6 /lib
      7. 2.2.7 /lost+found
      8. 2.2.8 /media
      9. 2.2.9 /mnt
      10. 2.2.10 /opt
      11. 2.2.11 /proc
      12. 2.2.12 /root
      13. 2.2.13 /run
      14. 2.2.14 /sbin
      15. 2.2.15 /selinux
      16. 2.2.16 /srv
      17. 2.2.17 /sys
      18. 2.2.18 /tmp
      19. 2.2.19 /usr
      20. 2.2.20 /var
    3. 2.3 Neue Benutzer und Gruppen einrichten
      1. 2.3.1 Einen User hinzufügen bzw. entfernen
      2. 2.3.2 Gruppen hinzufügen bzw. entfernen
    4. 2.4 Weiterführende Literatur
  6. Kapitel 3: Shell-Programmierung
    1. 3.1 Erste Schritte
      1. 3.1.1 Die Kommandos »man« und »info«
    2. 3.2 Geschichte der Shells
    3. 3.3 Die Bourne-again-Shell – bash
      1. 3.3.1 Ein- und Ausgabeumleitung
      2. 3.3.2 Shell-Variablen
      3. 3.3.3 Kommentare
      4. 3.3.4 Systemkommandos in Shellscripts
      5. 3.3.5 Mehrere Kommandos in einer Zeile
      6. 3.3.6 Bedingungen/Vergleiche
      7. 3.3.7 Funktionen in Shellscripts
      8. 3.3.8 Schleifen
      9. 3.3.9 Professionelle Übergabe von Argumenten
      10. 3.3.10 Einschränkungen bei Shellscripts
    4. 3.4 Weiterführende Literatur
  7. Kapitel 4: Cross-Toolchains
    1. 4.1 Cross-Toolchains für Raspberry Pi B+
      1. 4.1.1 Toolchain und IDE für Windows
      2. 4.1.2 Toolchain und IDE für Linux (Mint)
      3. 4.1.3 Toolchain und IDE für Mac OS X
    2. 4.2 Die Bibliothek wiringPi
      1. 4.2.1 Herunterladen von wiringPi
      2. 4.2.2 wiringPi »bauen«
      3. 4.2.3 Funktionen in wiringPi
      4. 4.2.4 Weitere Informationen zu wiringPi
      5. 4.2.5 Anschlussbelegung des Raspberry Pi B+
    3. 4.3 Konfiguration von Code::Blocks
      1. 4.3.1 Auswahl des Compilers
      2. 4.3.2 Einstellen der Compiler-Optionen
      3. 4.3.3 Bibliothek(en) hinzufügen
      4. 4.3.4 Erweitern des Suchpfades
      5. 4.3.5 Toolchain executables
      6. 4.3.6 Testen der Toolchain
    4. 4.4 crosstool-ng
      1. 4.4.1 Vorarbeiten
      2. 4.4.2 Erstellen und installieren von crosstool-ng
      3. 4.4.3 Toolchain konfigurieren
    5. 4.5 Weiterführende Literatur
  8. Teil II: Techniken zur Programmierung von Kernel und rootfs
  9. Kapitel 5: Raspbian – der Kernel
    1. 5.1 Überblick
      1. 5.1.1 Einmalig durchzuführende Schritte
      2. 5.1.2 Zu wiederholende Schritte
    2. 5.2 Kernel erzeugen – detaillierte Anleitung
      1. 5.2.1 Einmalig durchzuführende Schritte – Details
      2. 5.2.2 Zu wiederholende Schritte
    3. 5.3 Das Shellscript mkrpi
      1. 5.3.1 mkrpi – das Listing zum Shellscript
      2. 5.3.2 Funktion und Anwendung von mkrpi
    4. 5.4 Weiterführende Literatur
  10. Kapitel 6: Das root-Dateisystem – rootfs
    1. 6.1 rootfs erzeugen
      1. 6.1.1 Benötigte Software
      2. 6.1.2 Die nächsten Schritte
      3. 6.1.3 Imagedatei erzeugen
      4. 6.1.4 Schreiben der Boot-Partition
      5. 6.1.5 Schreiben des root-Dateisystems
      6. 6.1.6 Das Ende naht ...
    2. 6.2 Alternative Methode
      1. 6.2.1 Beschaffung und Anwendung von Buildroot
    3. 6.3 Weiterführende Literatur
  11. Kapitel 7: Der Bootprozess
    1. 7.1 Bare-Metal-Systeme
    2. 7.2 Geräte mit Betriebssystem
      1. 7.2.1 Der Bootprozess des Raspberry Pi
      2. 7.2.2 Der Bootprozess beim BeagleBone Black BBB
      3. 7.2.3 Der Bootprozess beim Cubieboard
    3. 7.3 Allgemeine Beschreibung des Bootvorgangs
      1. 7.3.1 Bootloader
      2. 7.3.2 Die Aufgabe von Bootloadern
    4. 7.4 Das U-Boot und der Raspberry Pi
      1. 7.4.1 Sourcecode von »Das U-Boot«
    5. 7.5 Weiterführende Literatur
  12. Teil III: Grundlagen der Treiberentwicklung
  13. Kapitel 8: Treiber und Module I
    1. 8.1 Auffrischung
    2. 8.2 »Normale« Dateien und Gerätedateien
      1. 8.2.1 Schnittstellen zwischen User Space und Kernel
      2. 8.2.2 Schnittstellen zwischen Kernel und Hardware
      3. 8.2.3 Wichtige Programme im User Space
    3. 8.3 Weitere Voraussetzungen
    4. 8.4 Das erste Kernelmodul
      1. 8.4.1 Quelltext des Moduls und Makefile
      2. 8.4.2 Kompilieren des Moduls
      3. 8.4.3 Modul testen
      4. 8.4.4 Details zu nix.c/nix.ko
      5. 8.4.5 kbuild
    5. 8.5 Ein weiteres einfaches Kernelmodul
      1. 8.5.1 Der Sourcecode
      2. 8.5.2 Log-Level
      3. 8.5.3 Kernelmodul ausprobieren
    6. 8.6 Moderne Variante von hellodriver
      1. 8.6.1 Moderne Variante des hellodriver-Moduls
    7. 8.7 Ende der Einführung
    8. 8.8 Weiterführende Literatur
  14. Kapitel 9: Treiber und Module II
    1. 9.1 Auf dem Weg zu einem richtigen Gerät
      1. 9.1.1 Funktionen, Makros, Datentypen
      2. 9.1.2 Der Sourcecode
    2. 9.2 Weiterführende Literatur
  15. Kapitel 10: Treiber und Module III
    1. 10.1 Checkliste für die Treiberentwicklung
      1. 10.1.1 Headerdateien
      2. 10.1.2 Die Struktur file_operations
      3. 10.1.3 Initialisierung eines Treibers/Moduls
      4. 10.1.4 Entfernen von Treibern/Modulen
      5. 10.1.5 Funktion mydevice_open
      6. 10.1.6 Funktion mydevice_close
      7. 10.1.7 Schreiben und Lesen
      8. 10.1.8 The End
      9. 10.1.9 Generelle Erklärung einiger Funktionen
    2. 10.2 Ansteuerung »echter« Hardware
      1. 10.2.1 GPIO-Funktionen
      2. 10.2.2 GPIOs anwenden
      3. 10.2.3 (Mögliche) Erweiterung des Treibers
    3. 10.3 Weiterführende Literatur
  16. Teil IV: Treiberentwicklung in der Praxis
  17. Kapitel 11: Praxis I
    1. 11.1 Das serielle Schieberegister SN74HC595
  18. Kapitel 12: Praxis II
    1. 12.1 Der Baustein Maxim 7219
      1. 12.1.1 Beschreibung des Maxim 7219
      2. 12.1.2 Zeitverhalten bei der Ansteuerung
      3. 12.1.3 Kaskadieren mehrerer Maxim 7219/7221
    2. 12.2 Ansteuerung einer 8 x 8-LED-Matrix
      1. 12.2.1 Der Schaltplan
    3. 12.3 Die Treibersoftware
      1. 12.3.1 Das Makefile
      2. 12.3.2 Die Headerdatei max7219.h
      3. 12.3.3 Der C-Sourcecode max7219imp.c
      4. 12.3.4 Das Testprogramm für den Treiber
      5. 12.3.5 Verbesserungsvorschläge
    4. 12.4 Ansteuerung von 7-Segment-Anzeigen
  19. Kapitel 13: Praxis III
    1. 13.1 Der HD44780 – Aus dem Datenblatt
    2. 13.2 Die Hardware
    3. 13.3 Die Headerdatei hd44780.h
      1. 13.3.1 Einige Erläuterungen
    4. 13.4 Der Treiber hd44780.c
      1. 13.4.1 Erläuterung des Programms
    5. 13.5 Das Testprogramm im User Space
    6. 13.6 Weiterführende Literatur
  20. Anhang A: Literaturverzeichnis
    1. A.1 Embedded Systeme, Architektur etc.
    2. A.2 VirtualBox
    3. A.3 Samba
    4. A.4 Shell-Programmierung
    5. A.5 Toolchains und Bibliotheken
    6. A.6 Bootstrapping, Buildroot etc.
    7. A.7 Der Bootprozess
    8. A.8 Pointer und Strukturen in C
    9. A.9 Das Kernel-Buildsystem und Treiber
    10. A.10 Bücher
  21. Anhang B: Belegung der GPIO-Ports
    1. B.1 GPIO-Belegung gemäß wiringPi
    2. B.2 GPIO-Belegung gemäß Broadcom
  22. Anhang C: Safety und Security
    1. C.1 Security
    2. C.2 Safety
      1. C.2.1 Maßnahmen in der Automobilindustrie
      2. C.2.2 Umsetzung in der Programmierung
    3. C.3 Ergänzende Literatur
  23. Anhang D: Kopieren mit scp
  24. Anhang E: Code::Blocks
    1. E.1 Projekteinstellungen
      1. E.1.1 Properties
      2. E.1.2 Build options ...