Un ouvrage de référence entièrement remis à jour P ...Linux embarqué Mise en place et développement Un ouvrage de référence entièrement remis à jour Depuis plus de 15 ans,

Linux

emba

rqué -

Mise

en pl

ace e

t dév

elopp

emen

tP.

Fich

eux Pierre Ficheux

Préface de Marc Palazon

Linux embarquéMise en place et développement

34 €

Studio Eyrolles © Éditions Eyrolles

Cod

e éd

iteur

: G

6748

4IS

BN

: 97

8-2-

212-

6748

4-2

Un ouvrage de référence entièrement remis à jourDepuis plus de 15 ans, date de parution de la première édition de Linux embarqué, le système d’exploitation Linux a acquis ses lettres de noblesse dans le domaine du logiciel embarqué et de l’informatique industrielle en général. Nombreux sont les produits industriels ou grand public qui l’utilisent : citons les boîtiers d’accès à Internet, les téléviseurs et, bien entendu, la plupart des smartphones équipés du système Android de Google (basé sur le noyau Linux). Le marché de l’automobile est également friand de Linux pour la partie IVI (In Vehicle Infotain-ment). N’oublions pas, enfin, le domaine naissant de l’Internet des objets (IoT).Cet ouvrage constitue une version totalement revue des éditions précédentes (Linux embarqué versions 1 à 4). Plus concis et mieux ciblé, il fait volontairement l’impasse sur certains chapitres généraux au bénéfice d’une étude approfondie des outils et composants phares de l’environnement Linux pour l’embarqué (Yocto, Buildroot, U-Boot, Eclipse ou bien OpenOCD). L’ouvrage décrit en détail la construction d’une distribution Linux optimisée pour la cible (BSP), ainsi que l’environnement de développement associé (SDK). Un chapitre évoque les techniques de développement (Autotools, CMake), mise au point (GDB) et profilage (Ftrace), ainsi que l'utilisation de l'environnement graphique Eclipse. Toujours pour rester dans l’air du temps, la quasi-totalité des démonstrations sont réalisées sur la célèbre carte Raspberry Pi 3, que bon nombre de technophiles possèdent déjà. Dans le cas contraire, le lecteur pourra l'acquérir pour environ 30 €. La carte BeagleBone Black (à peu près équivalente) est également utilisée dans le chapitre consacré à U-Boot.Les manipulations décrites dans cet ouvrage sont réalisables quelle que soit la distribution utilisée sur le poste de développement. Cepen-dant, nous avons choisi la distribution Ubuntu 16.04.3 (LTS). Tous les exemples de programmes du livre sont en téléchargement sur notre site Internet, www.editions-eyrolles.com/dl/0067484, ou bien sur la page GitHub de l’auteur, à l’adresse https://github.com/pficheux/LE5.

À qui s’adresse ce livre ? • Aux développeurs Linux et ingénieurs ayant à réaliser des systèmes embarqués.• Aux étudiants désirant parfaire leurs connaissances sur ce sujet.• Plus généralement à tous ceux ayant déjà une expérience de Linux et désirant se familiariser avec son utilisation comme système embarqué.

Ingénieur des Arts et Métiers, Pierre Ficheux est un « linuxien » de renom, auteur de nombreux tutoriels et articles dans la presse spécialisée. Il a travaillé notamment chez Red Hat Software et s’est spécialisé dans les applications industrielles de Linux. Cofondateur d’Open Wide en 2001, il est aujourd’hui directeur technique de Smile-ECS (Embedded & Connected Systems), branche du groupe Smile spécialisée dans les technologies open source appliquées aux systèmes embarqués et à l’IoT. II est également enseignant et responsable de la majeure GISTRE de l’EPITA (Paris).

Au sommaire Introduction aux systèmes embarqués. Tour d’horizon des systèmes d’exploitation existants • Rappels sur Linux et le logiciel libre. Logiciel libre, concepts et licences • From UNIX to Linux • Le noyau Linux • Répertoires et �chiers principaux • Développer pour Linux embarqué. Plate-forme cible • Machine hôte • Développer pour Linux (embarqué) • Introduction au développement noyau • Mise au point avec GDB • Utilisation de QEMU • Construire une distribution. Distribution standard ou construite ? • Installation de la distribution Raspbian • Méthode de création • Test du système sur la cible • De l’utilité d’un outil de construction • Utiliser Buildroot. Premier test pour Raspberry Pi 3 • Fonction-nement et con�guration • Ajout de paquets et con�guration externe • Commandes et outils divers • Utiliser Yocto. Premier test sur QEMU/x86 et Raspberry Pi 3 • Fonctionnement et con�guration • Enrichir l’image • Création de recettes • Techniques avancées sur les recettes • Interface graphique • Image et « distro » • Création et utilisation du SDK • Utiliser U-Boot. Utilisation et con�guration d’U-Boot • Étude de cas « IoT ». Bus I2C • Construction de l’image • Visualisation des données

Exemples réalisés sur

Raspberry Pi 3

G67484_LinuxEmbarqué_EXE.indd 1 25/10/2017 11:44

Linux

emba

rqué -

Mise

en pl

ace e

t dév

elopp

emen

tP.

Fich

eux Pierre Ficheux



Un ouvrage de référence entièrement remis à jourDepuis plus de 15 ans, date de parution de la première édition de Linux embarqué, le système d’exploitation Linux a acquis ses lettres de noblesse dans le domaine du logiciel embarqué et de l’informatique industrielle en général. Nombreux sont les produits industriels ou grand public qui l’utilisent : citons les boîtiers d’accès à Internet, les téléviseurs et, bien entendu, la plupart des smartphones équipés du système Android de Google (basé sur le noyau Linux). Le marché de l’automobile est également friand de Linux pour la partie IVI (In Vehicle Infotain-ment). N’oublions pas, enfin, le domaine naissant de l’Internet des objets (IoT).Cet ouvrage constitue une version totalement revue des éditions précédentes (Linux embarqué versions 1 à 4). Plus concis et mieux ciblé, il fait volontairement l’impasse sur certains chapitres généraux au bénéfice d’une étude approfondie des outils et composants phares de l’environnement Linux pour l’embarqué (Yocto, Buildroot, U-Boot, Eclipse ou bien OpenOCD). L’ouvrage décrit en détail la construction d’une distribution Linux optimisée pour la cible (BSP), ainsi que l’environnement de développement associé (SDK). Un chapitre évoque les techniques de développement (Autotools, CMake), mise au point (GDB) et profilage (Ftrace), ainsi que l'utilisation de l'environnement graphique Eclipse. Toujours pour rester dans l’air du temps, la quasi-totalité des démonstrations sont réalisées sur la célèbre carte Raspberry Pi 3, que bon nombre de technophiles possèdent déjà. Dans le cas contraire, le lecteur pourra l'acquérir pour environ 30 €. La carte BeagleBone Black (à peu près équivalente) est également utilisée dans le chapitre consacré à U-Boot.Les manipulations décrites dans cet ouvrage sont réalisables quelle que soit la distribution utilisée sur le poste de développement. Cepen-dant, nous avons choisi la distribution Ubuntu 16.04.3 (LTS). Tous les exemples de programmes du livre sont en téléchargement sur notre site Internet, www.editions-eyrolles.com/dl/0067484, ou bien sur la page GitHub de l’auteur, à l’adresse https://github.com/pficheux/LE5.

À qui s’adresse ce livre ? • Aux développeurs Linux et ingénieurs ayant à réaliser des systèmes embarqués.• Aux étudiants désirant parfaire leurs connaissances sur ce sujet.• Plus généralement à tous ceux ayant déjà une expérience de Linux et désirant se familiariser avec son utilisation comme système embarqué.

Ingénieur des Arts et Métiers, Pierre Ficheux est un « linuxien » de renom, auteur de nombreux tutoriels et articles dans la presse spécialisée. Il a travaillé notamment chez Red Hat Software et s’est spécialisé dans les applications industrielles de Linux. Cofondateur d’Open Wide en 2001, il est aujourd’hui directeur technique de Smile-ECS (Embedded & Connected Systems), branche du groupe Smile spécialisée dans les technologies open source appliquées aux systèmes embarqués et à l’IoT. II est également enseignant et responsable de la majeure GISTRE de l’EPITA (Paris).

Au sommaire Introduction aux systèmes embarqués. Tour d’horizon des systèmes d’exploitation existants • Rappels sur Linux et le logiciel libre. Logiciel libre, concepts et licences • From UNIX to Linux • Le noyau Linux • Répertoires et �chiers principaux • Développer pour Linux embarqué. Plate-forme cible • Machine hôte • Développer pour Linux (embarqué) • Introduction au développement noyau • Mise au point avec GDB • Utilisation de QEMU • Construire une distribution. Distribution standard ou construite ? • Installation de la distribution Raspbian • Méthode de création • Test du système sur la cible • De l’utilité d’un outil de construction • Utiliser Buildroot. Premier test pour Raspberry Pi 3 • Fonction-nement et con�guration • Ajout de paquets et con�guration externe • Commandes et outils divers • Utiliser Yocto. Premier test sur QEMU/x86 et Raspberry Pi 3 • Fonctionnement et con�guration • Enrichir l’image • Création de recettes • Techniques avancées sur les recettes • Interface graphique • Image et « distro » • Création et utilisation du SDK • Utiliser U-Boot. Utilisation et con�guration d’U-Boot • Étude de cas « IoT ». Bus I2C • Construction de l’image • Visualisation des données

Exemples réalisés sur

Raspberry Pi 3

G67484_LinuxEmbarqué_EXE.indd 1 25/10/2017 11:44

http://www.editions-eyrolles.com


349101_LinuxEmbarque.indd I349101_LinuxEmbarque.indd I 24/10/2017 11:1924/10/2017 11:19

DANS LA MÊME COLLECTION

M. BIDAULT. – Programmation Excel avec VBA.

No67401, 2017, 480 pages.P. MARTIN, J. PAULI, C.PIERRE DE GEYER. – PHP 7 avancé.

No14357, 2016, 732 pages.L. BLOCH, C. WOLFHUGEL, A. KOKOS, G. BILLOIS, A. SOULLIÉ, T. DEBIZE. – Sécurité informatique.

No11849, 2016, 648 pages.R. GOETTER. – CSS 3 Flexbox.

No14363, 2016, 152 pages.W. MCKINNEY. – Analyse de données en Python.

No14109, 2015, 488 pages.E. BIERNAT, M. LUTZ. – Data science : fondamentaux et études de cas.

No14243, 2015, 312 pages.B. PHILIBERT. – Bootstrap 3 : le framework 100 % web design.

No14132, 2015, 318 pages.C. CAMIN. – Développer avec Symfony2.

No14131, 2015, 474 pages.S. PITTION, B. SIEBMAN. – Applications mobiles avec Cordova et PhoneGap.

No14052, 2015, 184 pages.H. GIRAUDEL, R. GOETTER. – CSS 3 : pratique du design web.

No14023, 2015, 372 pages.C. DELANNOY. – Le guide complet du langage C.

No14012, 2014, 844 pages.

SUR LE MÊME THÈME

P. FICHEUX, E. BÉNARD. – Linux embarqué.

No13482, 4e édition, 2012, 540 pages.K. NOVAK. – Débuter avec LINUX.

No13793, 2017, 522 pages.M. RICHARDSON, S. WALLACE. – À la découverte du Raspberry PI.

No13747, 2014, 212 pages.

Retrouvez nos bundles (livres papier + e-book) et livres numériques surhttp://izibook.eyrolles.com

349101_LinuxEmbarque.indd II349101_LinuxEmbarque.indd II 24/10/2017 11:1924/10/2017 11:19

Pierre Ficheux



349101_LinuxEmbarque.indd III349101_LinuxEmbarque.indd III 24/10/2017 11:1924/10/2017 11:19

Éditions Eyrolles61, bd Saint-Germain75240 Paris Cedex 05

www.editions-eyrolles.com

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre français d’exploitation du droit de copie, 20, rue des Grands-Augustins, 75006 Paris.

© Groupe Eyrolles, 2018, ISBN : 978-2-212-67484-2

349101_LinuxEmbarque.indd IV349101_LinuxEmbarque.indd IV 24/10/2017 11:1924/10/2017 11:19

Préface

C’est avec fi erté que je prends le clavier pour rédiger ces quelques lignes de préface de l’ouvrage Linux embarqué, mise en place et développement rédigé par notre compagnon de route Pierre Ficheux.Cet ouvrage est pour moi le parfait symbole de ce qui caractérise l’open source : inno-vation, collaboration mais aussi pérennité. En effet, si l’open source est entré dans les entreprises, ce n’est pas juste pour satisfaire l’appétit de programmeurs à la recherche de technologies de pointe, mais c’est véritablement que les bénéfi ces sont énormes.Les administrations, les grandes entreprises, les géants d’Internet, les start-up inno-vantes s’appuient désormais massivement sur des composants et grands produits open source. Ce n’est pas l’objet ici de faire le recensement complet des bénéfi ces à déployer des produits open source mais retenez toutefois ceux-ci :• pérennité et, en cela, Linux embarqué en est une parfait illustration ;• liberté de choix : une moindre dépendance (lock-in) vis-à-vis d’un petit nombre de

fournisseurs en situation de quasi-monopole ou d’oligopole ;• respect ou création des standards : les logiciels open source sont par nature plus

respectueux des standards, à la fois parce que c’est la condition pour qu’ils s’ap-puient eux-mêmes sur d’autres briques open source, mais aussi parce qu’ils ne sont pas dans une logique de protection. Certains des grands logiciels open source comme Linux sont d’ailleurs devenus des standards de fait ;

• dynamique d’évolution : les logiciels open source ont un développement qui s’ap-puie en tout ou partie sur une large communauté de développeurs, ce qui permet une puissance de recherche et développement inégalable.

Aujourd’hui, dans un monde en profonde mutation digitale, les entreprises, les ins-titutions, les associations ont le devoir impérieux d’innover et de se transformer. Il en va de leur développement, parfois de leur survie, et cela passe massivement par de profondes mutations au sein de leur IT.

349101_LinuxEmbarque.indd V349101_LinuxEmbarque.indd V 24/10/2017 11:1924/10/2017 11:19

VI Linux embarqué

Je suis personnellement persuadé que ce changement n’est possible qu’à deux condi-tions essentielles et indissociables : l’open source et la transformation.• L’open source comme un accélérateur de l’innovation, un « mouvement » profond

qui s’appuie sur des valeurs essentielles, dont l’intelligence collective et le partage.• La transformation : à l’opposé de la rupture, les organisations (institutions,

entreprises, associations) doivent se réinventer en profondeur pour s’adapter aux modèles de demain.

Toutes ces années d’investissement personnel et collectif en faveur de l’open source n’ont fait qu’encourager notre croyance dans ce modèle alternatif. Au-delà de l’open source, je suis persuadé que seul le « numérique ouvert » a la capacité de transfor-mer durablement nos sociétés en libérant le potentiel d’innovation inscrit dans cha-cune d’elles. Le numérique ouvert englobe bien sûr l’open source, mais va au-delà en valorisant de nouvelles méthodes de travail et de conception (méthode agile, « lean start-up », hackathon), l’open data, l’accessibilité, les standards libres, l’interopérabi-lité, le savoir libre, l’innovation ouverte, etc.

La transparence et le travail collaboratif, chantres de l’économie du partage, sont plus que jamais sources d’innovations disruptives, tant d’un point de vue économique que sociétal. Nous avons tous à gagner à rendre l’IT plus ouvert.

Marc PalazonPrésident de SMILE

www.smile.fr

349101_LinuxEmbarque.indd VI349101_LinuxEmbarque.indd VI 24/10/2017 11:1924/10/2017 11:19

Table des matières

Avant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIII

CHAPITRE 1Introduction aux systèmes embarqués ................................................... 1

Qu’est-ce qu’un système embarqué ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1Évolution vers le système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Et l’IoT dans tout ça ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Tour d’horizon des systèmes d’exploitation existants . . . . . . . . . . . . . . . . . . . . 5

FreeRTOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5VxWorks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6QNX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6µC/OS II (micro-C/OS II) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Windows Embedded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6LynxOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Nucleus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7VRTX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7eCos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Contiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7RIOT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

CHAPITRE 2Rappels sur Linux et le logiciel libre ........................................................ 9

Logiciel libre, concepts et licences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Licence GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Isolation et licence LGPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Espace du noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Licence GPL v3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Licence Apache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Outils liés aux licences libres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

From UNIX to Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

349101_LinuxEmbarque.indd VII349101_LinuxEmbarque.indd VII 24/10/2017 11:1924/10/2017 11:19

VIII Linux embarqué

Le noyau Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Répertoires et fi chiers principaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Organisation générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Le répertoire /dev . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Le système de fi chiers proc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Le système de fi chiers sysfs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Gestion des services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Les bibliothèques partagées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Le répertoire /var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Pourquoi Linux est-il adapté à l’embarqué ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Dans quels cas Linux peut-il être inadapté ? . . . . . . . . . . . . . . . . . . . . . . . . 22

Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

CHAPITRE 3Développer pour Linux embarqué ........................................................... 25

Plate-forme cible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Machine hôte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Développer pour Linux (embarqué) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

L’instant de l’Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Choix d’une chaîne croisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Chaîne fournie avec la distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32Chaîne binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Chaîne produite à partir des sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Outils de construction de projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36GNU Autotools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37CMake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Introduction au développement noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Un module « Hello World » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Cas de la compilation croisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

Mise au point avec GDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44Utilisation de GDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Mise au point d’un exécutable (espace utilisateur) . . . . . . . . . . . . . . . . . . 45Mise au point en espace noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Introduction au JTAG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49Présentation et mise en place d’OpenOCD . . . . . . . . . . . . . . . . . . . . . . 50Confi guration de la cible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51Confi guration de la sonde et test de l’accès JTAG . . . . . . . . . . . . . . . . . . 53Mise au point d’un pilote de périphérique . . . . . . . . . . . . . . . . . . . . . . . 54

Autres outils de mise au point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57La commande strace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

349101_LinuxEmbarque.indd VIII349101_LinuxEmbarque.indd VIII 24/10/2017 11:1924/10/2017 11:19

IXTable des matières

Utilisation de Ftrace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Test du traceur de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60Test du traceur d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Utilisation de QEMU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

CHAPITRE 4Construire une distribution ....................................................................... 69

Distribution standard ou construite ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69Installation de la distribution Raspbian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70Méthode de création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

L’outil BusyBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Squelette du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74Choix d’un compilateur croisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75Compilation de BusyBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76Installation des bibliothèques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Test du système sur la cible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78De l’utilité d’un outil de construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

CHAPITRE 5Utiliser Buildroot .......................................................................................... 83

Historique et introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83Premier test pour Raspberry Pi 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84Fonctionnement et confi guration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Options de construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92Choix d’une chaîne de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Confi guration du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Prise en compte du répertoire /dev . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97Utilisation des « overlays » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98Utilisation des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

Sélection du noyau Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100Choix des composants de la distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . 101Choix des formats des images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105Choix du bootloader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107Construction d’utilitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107Traitement des options obsolètes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

Ajout de paquets et confi guration externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

349101_LinuxEmbarque.indd IX349101_LinuxEmbarque.indd IX 24/10/2017 11:1924/10/2017 11:19

X Linux embarqué

Exemples de recettes simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108Exemple basé sur Autotools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108Exemple basé sur CMake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Exemple basé sur un fi chier Makefi le. . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Ajout des recettes à Buildroot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111Mise en place d’une arborescence br2-external . . . . . . . . . . . . . . . . . . . . . . . 111Autres options « avancées » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

Commandes et outils divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

Exercice 1 (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120Exercice 2 (**) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

CHAPITRE 6Utiliser Yocto ................................................................................................. 121

Historique et introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121Premier test sur QEMU/x86 et Raspberry Pi 3 . . . . . . . . . . . . . . . . . . . . . . . . 123Fonctionnement et confi guration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Description des layers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129Répertoires produits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Fichiers à installer, installés ou installables . . . . . . . . . . . . . . . . . . . . . . . 130Répertoires de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Notion de recette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132Notion de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133Fichier d’inclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133Fichier de confi guration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133Utilisation de BitBake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133Syntaxe d’affectation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

Enrichir l’image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138Ajout de recettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139Ajout de « features » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

Création de recettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142Un premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142Serveur de paquets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144Les différents types de recettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

Exemple avec sources locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147Exemple basé sur un fi chier Makefi le. . . . . . . . . . . . . . . . . . . . . . . . . . . 150Exemple basé sur Autotools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151Exemple basé sur CMake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

Techniques avancées sur les recettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

349101_LinuxEmbarque.indd X349101_LinuxEmbarque.indd X 24/10/2017 11:1924/10/2017 11:19

XITable des matières

Dépendances des recettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152Intégration d’un patch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154Utilisation d’un fi chier .bbappend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155Priorités des layers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158Ajout et défi nition de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159Recettes du noyau et des modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

Recette du noyau Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160Intégration d’un module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168Test de X11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169Test de Wayland . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171Test de Qt 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Image et « distro » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173Notion de « package group » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175Notion de « distro » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

Création et utilisation du SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177Outils et sujets divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

Gestion des licences « commerciales » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179Paramètres nationaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179Assurance qualité (QA) et intégration continue . . . . . . . . . . . . . . . . . . . . . . 180

QA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181Intégration continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

Test unitaire (Ptest) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181Test de l’image (testimage) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

Exercice 1 (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188Exercice 2 (**) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

CHAPITRE 7Utiliser U-Boot ............................................................................................... 189

Introduction à U-Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189Test sur BeagleBone Black . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190Compilation d’U-Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

Utilisation et confi guration d’U-Boot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194La syntaxe d’U-Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

Exemples de manipulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194Liste des principales commandes et variables . . . . . . . . . . . . . . . . . . . . . . 195

Création de macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196Utilisation d’une mémoire fl ash NOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

349101_LinuxEmbarque.indd XI349101_LinuxEmbarque.indd XI 24/10/2017 11:1924/10/2017 11:19

XII Linux embarqué

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

CHAPITRE 8Étude de cas « IoT » ...................................................................................... 205

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205Bus I²C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206Construction de l’image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Connexion Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209Utilisation du capteur I²C (MPL115A2) . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

Confi guration du bus I²C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210Pilotage du capteur MPL115A2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

Ajout de MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213Recette de l’image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

Visualisation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215Exercice (***) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

Index ................................................................................................................. 217

349101_LinuxEmbarque.indd XII349101_LinuxEmbarque.indd XII 24/10/2017 11:1924/10/2017 11:19

Avant-propos

Cet ouvrage a pour but de présenter les différentes techniques disponibles pour la création de systèmes embarqués sous Linux. Il correspond à peu près à l’enseignement que je dispense dans les écoles d’ingénieurs ou lors de formations professionnelles.

De nombreux exemples de fi chiers de confi guration Linux, codes sources en C, scripts shell et « recettes » Buildroot ou Yocto agrémentent la démonstration. S’il faut choisir des qualifi catifs pour cet ouvrage, les mots concret et pragmatique arrivent largement en tête ! Le logiciel libre est beaucoup plus mature qu’il y a 15 ans – date de sortie de la première édition – et la documentation des projets libres majeurs est désormais très complète. Le but du livre n’est donc pas de paraphraser ces documents, mais de donner des exemples pédagogiques et abordables permettant au lecteur d’en tirer le meilleur parti.

Les concepts décrits dans cet ouvrage sont valables quelle que soit la distribution utilisée sur le poste de développement. Cependant, nous avons utilisé la distribution Ubuntu 16.04 (LTS) pour l’ensemble des manipulations.

À qui ce livre s’adresse-t-il ?Ce livre s’adresse à un public ayant déjà une expérience de Linux et désirant se familia-riser avec son utilisation comme système embarqué. Des étudiants peuvent également y trouver source d’inspiration. La lecture complète de l’ouvrage nécessite des notions de programmation en langage C et scripts shell, ainsi que quelques connaissances générales en informatique industrielle. Les sources des exemples présentés sont dis-ponibles en téléchargement à l’adresse https://github.com/pfi cheux/LE5.

349101_LinuxEmbarque.indd XIII349101_LinuxEmbarque.indd XIII 24/10/2017 11:1924/10/2017 11:19

https://github.com/pficheux/LE5

XIV Linux embarqué

Structure de l’ouvrageL’ouvrage est divisé en plusieurs chapitres, auxquels s’ajoute une étude de cas. Une brève introduction traite des systèmes embarqués en général, ainsi que de leur champ d’application.

Le deuxième chapitre rappellera quelques notions concernant le logiciel libre, les licences associées et quelques éléments sur Linux au niveau de son architecture sys-tème (espaces noyau et utilisateur, démarrage, principaux fi chiers remarquables). Nous conclurons par les avantages et inconvénients de l’utilisation de Linux pour les systèmes embarqués.

Le chapitre suivant décrira les outils et méthodes dédiés au développement pour Linux embarqué (compilation croisée, Autotools, CMake). Les outils de mise au point (GDB, Ftrace) seront également abordés. En introduction, nous décrirons briè-vement le matériel utilisable, même si l’évolution du marché rend forcément cette inventaire très rapidement obsolète. On peut cependant noter que les plates-formes les plus répandues (Raspberry Pi, BeagleBone Black et autres modules i.MX6) existent depuis plusieurs années, mais il peut en être tout autrement des outsiders.

Nous aborderons ensuite un exemple de réalisation d’un système Linux embarqué minimal à partir de composants standards (le noyau Linux et l’outil BusyBox). Ce chapitre a un but purement pédagogique avant d’aborder les véritables outils de construction de distribution.

Une bonne partie de l’ouvrage – presque la moitié – sera ensuite consacrée aux deux principaux outils utilisés pour la création de distributions : Buildroot et Yocto. Nous décrirons ensuite le bootloader U-Boot et son utilisation pour la carte BeagleBone Black.

Nous terminerons l’ouvrage par une étude de cas mettant en œuvre un « objet connecté » (c’est la mode), chargé de mesurer des grandeurs physiques que l’on pourra visualiser sur une application mobile.

Précisions concernant la cinquième éditionCinq ans ont passé depuis la sortie de la quatrième édition de l’ouvrage Linux embar-qué. Mis à part quelques paragraphes, cette nouvelle édition est entièrement nouvelle par rapport à la précédente. Cette dernière était un « pavé » de 540 pages et nous avons pris le parti de réaliser une cinquième édition beaucoup plus légère (environ 240 pages), donc moins onéreuse. En effet, il existe désormais une littérature assez fournie sur le sujet et les chapitres très généraux n’ont plus d’intérêt pour le lecteur.

349101_LinuxEmbarque.indd XIV349101_LinuxEmbarque.indd XIV 24/10/2017 11:1924/10/2017 11:19

XVAvant-propos

Nous avons également écarté des sujets comme Linux temps réel ou les IHM, sachant que – pour le premier sujet – il existe déjà aux éditions Eyrolles un excellent ouvrage spécialisé, écrit par mon camarade Christophe Blaess.

RemerciementsDe par mon attachement à la revue Linux Magazine et aux publications des éditions Diamond, je me suis efforcé de prendre la direction de la rédaction du journal Open Silicium, dédié aux logiciels et matériels libres pour les systèmes embarqués. L’aven-ture a duré un an, du numéro 16 (décembre 2015) au numéro 20 (décembre 2016). Les spécialistes du domaine étant peu nombreux et très peu disponibles, il était com-pliqué de fournir des articles novateurs malgré la fréquence de publication de trois mois. J’étais donc à l’époque très occupé par la chasse aux auteurs et la rédaction d’une bonne partie du magazine ; l’arrêt de la publication du magazine début 2017 était prévisible et fut décidé d’un commun accord avec les éditions Diamond. Cet événe-ment malheureux m’a permis de m’atteler à la rédaction de cette nouvelle édition. J’en profi te pour remercier encore une fois Denis Bodor et Arnaud Metzler pour m’avoir proposé l’aventure.

Cette édition est restée fi dèle à l’objectif initial : être un support pratique à l’utilisation des technologies Linux dans le monde industriel. Outre les nombreuses formations dispensées sur le sujet, mon cercle d’auditeurs s’est enrichi de plusieurs écoles d’in-génieurs prestigieuses, dans lesquelles le logiciel libre a acquis une place de choix dans les programmes de spécialisation. Je citerai une nouvelle fois l’EPITA, pour laquelle j’ai la charge depuis presque 10 ans de diriger la majeure GISTRE (Génie Informatique des Systèmes Temps Réel et Embarqués). Je remercie donc Christian Dujardin, Pedro Miranda, Laurent Trébulle et Audrey Paris, avec lesquels je collabore très fréquemment afi n de transmettre la bonne parole à nos chers étudiant(e)s ! Merci également à Thierry Joubert – enseignant à l’EPITA –, qui s’éloigne peu à peu de Windows Embedded :-).

Je profi te de cette nouvelle édition pour remercier des collègues et amis qui ont contribué de près ou de loin à la genèse de cet ouvrage. En premier lieu, je remercie de nouveau l’équipe d’Open Wide Ingénierie (devenue Smile-ECS), dont l’intérêt pour Linux embarqué ne faiblit pas. Merci à Alexandre Lahaye, Arnaud Carrère, Fabrice Dewasmes, Cédric Ravalec, Louis Rannou et Damien Lagneux, qui allient compé-tence et bonne humeur. Citons également l’équipe des experts ECS, dont Romain Naour, Fabien Dutuit, Vincent Dehors, Jérémy Rosen, Pierre Lamot, et enfi n la Direction ECS avec Christophe Brunschweiler et Grégory Bécue.

349101_LinuxEmbarque.indd XV349101_LinuxEmbarque.indd XV 24/10/2017 11:1924/10/2017 11:19

XVI Linux embarqué

Merci également à Christophe Blaess, spécialiste reconnu de Linux embarqué et auteur de plusieurs ouvrages chez Eyrolles, avec lequel le partage d’information est toujours profi table. J’adresse un amical clin d’œil à Gilles Blanc, autre spécialiste du domaine doté d’un sens de l’humour et de la repartie sans faille. Merci également à Patrice Kadionik de l’ENSEIRB-MATMECA, Karim Yaghmour et Chris Sim-monds. Je remercie une nouvelle fois Muriel Shan Sei Fan qui – même si elle ne fait plus partie des éditions Eyrolles – a contribué à la continuité de mon intérêt pour l’écriture. Enfi n, je remercie Alexandre Habian des éditions Eyrolles, qui a su insister plusieurs fois avant que je me décide à reprendre la plume pour cette nouvelle édition !

Outre des collaborateurs ou soutiens techniques, plusieurs auteurs et artistes gravitant dans le monde de l’écriture m’ont aidé ou infl uencé dans ma tâche. Je citerai parmi eux Michel Audiard, Pierre Desproges et, bien sûr, l’incomparable Molière.

Que le noyau Linux est un fort beau projet

Méritant qu’on passe vacances et soirées

Et que Linus Torvalds en soit ici loué

Pour avoir pu ainsi sauver l’humanité.

Au moment de la relecture de l’ouvrage, j’apprends avec tristesse le décès prématuré de François Peiffer qui fut longtemps Directeur de la recherche et du développement chez Lectra (https://www.lectra.com/fr), entreprise bordelaise emblématique spécialisée dans les logiciels et matériels de découpe. J’ai passé 8 ans chez Lectra, et en 1995 il m’avait soutenu pour le choix de l’utilisation de Linux pour les logiciels développés par l’entreprise. Personnalité forte et charismatique, François m’a beaucoup infl uencé durant ma vie professionnelle et je tenais ici à honorer sa mémoire en lui dédiant cet ouvrage.

Pierre Ficheux(août 2017)

349101_LinuxEmbarque.indd XVI349101_LinuxEmbarque.indd XVI 24/10/2017 11:1924/10/2017 11:19

1Introduction

aux systèmes embarqués

Avant d’entrer dans le vif du sujet, nous allons évoquer un bref historique et les princi-pales caractéristiques des systèmes embarqués. Nous citerons également les systèmes d’exploitation les plus utilisés dans le domaine.

Qu’est-ce qu’un système embarqué ?Par défi nition, un système embarqué est l’association de matériel (un calculateur) et de logiciel. Contrairement à l’informatique classique (poste de travail « desktop » ou serveur), le système est dédié à un ensemble fi ni de fonctionnalités et il en est de même pour le logiciel.

Historiquement, les premiers domaines d’application étaient limités à l’armement et au spatial, pour lesquels les coûts des programmes sont très élevés. En effet, l’une des diffi cultés notoires de l’époque était l’absence de microprocesseur, car le 4004 – premier microprocesseur disponible commercialement – fut créé par Intel (seule-ment) en 1971. Dans le domaine spatial, on s’accorde à dire que le premier système embarqué fut l’Apollo Guidance Computer, créé en 1967 par le MIT pour la mission lunaire Apollo.

349101_LinuxEmbarque.indd 1349101_LinuxEmbarque.indd 1 24/10/2017 11:1924/10/2017 11:19

2 Linux embarqué

Calculateur Apollo Guidance Computer

Ce système disposait de 36 kilomots de ROM, 2 kilomots de RAM et fonctionnait à la fréquence de 2 MHz. De nos jours, on peut simuler le comportement de ce cal-culateur grâce à une page web animée par du langage Javascript (voir http://svtsim.com/moonjs/agc.html). Dans le domaine des applications militaires, on évoque également le calculateur D-17B, système de guidage pour le missile LGM-30 datant du début des années 1960.

Calculateur D-17B

Il n’était pas question à l’époque d’évoquer la notion de système d’exploitation embarqué ; on parlait simplement de logiciel embarqué écrit en langage machine. En


http://svtsim.com/moonjs/agc.html

http://svtsim.com/moonjs/agc.html

3Introduction aux systèmes embarqués CHAPITRE 1

revanche, le programme Apollo utilisait de nombreux calculateurs IBM/360 au sol et le logiciel le plus complexe de la mission occupait 6 Mo. Sur cet IBM/360, la NASA utilisait une version temps réel de l’OS/360 nommée RTOS/360.

REMARQUE

Encore de nos jours, même si l’on utilise désormais des langages évolués comme C/C++, Java ou Ada, certains systèmes embarqués sont toujours dépourvus de système d’exploitation. On parle alors de logi-ciel bare metal.

Évolution vers le système d’exploitationÀ partir des années 1980, l’évolution technologique permet à de nombreux systèmes d’exploitation temps réel ( RTOS pour Real Time Operating System) de fonctionner sur des processeurs du commerce, les RTOS étant pour la plupart diffusés par des éditeurs spécialisés. Nous pouvons citer VRTX (1981) édité par Mentor Graphics et célèbre pour être utilisé dans le télescope Hubble, VxWorks (1987) édité par Wind River et LynxOS (1986) édité par LynuxWorks. VxWorks est toujours très utilisé dans les industries sensibles comme le spatial et fut entre autres choisi pour la sonde spatiale Pathfi nder (1996), ainsi que pour la mission Curiosity lancée en 2011 et tou-jours active. Dans le domaine du logiciel libre, RTEMS est également fréquemment choisi par la NASA ou l’agence européenne (ESA). Initialement dédié au guidage des missiles, ce système diffusé sous licence GPL est utilisé pour le système de communi-cation de Curiosity, ainsi que pour de nombreuses autres missions.

À partir des années 2000, l’utilisation des systèmes embarqués ne se limite plus aux applications industrielles ou temps réel, ce qui permet la percée d’un système comme Linux (qui, par défaut, n’a pas de capacités temps réel). Linux est désormais présent dans 95 % des boîtiers d’accès à Internet, décodeurs TV (set-top box), sans compter le noyau du système d’exploitation Android. De par ses capacités graphiques, ce dernier est désormais présent dans plusieurs boîtiers d’accès à la télévision numérique basés sur Android TV, ainsi que sur quelques applications embarquées dans le domaine du médical ou des terminaux spécialisés (bornes interactives).

Plus récemment, des alliances d’acteurs de l’industrie automobile ont permis la mise en place de projets comme GENIVI ou Automotive Grade Linux – AGL (basés sur Linux), dont le but est de créer des composants logiciels standardisés pour les appli-cations IVI (In Vehicle Infotainment).

Les systèmes doivent souvent respecter des contraintes de sûreté de fonctionne-ment et de déterminisme. Ce point est fondamental, car il détermine le choix des


4 Linux embarqué

composants logiciels à utiliser. Dans le cas d’un système non contraint, on pourra envisager un système d’exploitation directement adapté d’une version standard d’un système comme Linux, voire modifi é par PREEMPT_RT ou Xenomai pour disposer de capacités temps réel. L’adaptation se situera au niveau du développement de pilotes de périphériques et de l’optimisation du système en taille ou en performances. Dans le cas d’un système contraint, on devra souvent utiliser des composants spécialisés et un système d’exploitation dédié ou bien des techniques de « co-design » (Linux associé à un microcontrôleur ou un FPGA, voir http://kadionik.vvv.enseirb-matmeca.fr/se/ projets_avances/1617/rapport_sujet6_SE_1617.pdf).

REMARQUE

Dans le cas d’applications soumises à de fortes contraintes de sûreté de fonctionnement, les logiciels embarqués doivent respecter des normes internationales strictes, comme la certifi cation DO-178 utilisée dans le transport aérien civil. On utilise alors des systèmes d’exploitation dédiés, répondant à des stan-dards comme ARINC 653 , qui assurent un partitionnement spatial et temporel des différentes tâches : ces dernières s’exécutent dans des espaces de mémoire étanches et sont ordonnancées en suivant des priorités fi xes. Le site http://www.open-do.org décrit des outils basés sur des logiciels libres et utilisés dans le cas de telles contraintes de certifi cation. Ce site est maintenu par la société AdaCore.

Le domaine de l’équipement grand public a longtemps échappé aux systèmes embar-qués, tout d’abord pour des raisons de coût du matériel. De plus, ces équipements fonctionnaient de manière isolée et n’avaient jusqu’ici aucun lien avec les réseaux informatiques. Le développement des services sur Internet – et, de nos jours, l’In-ternet des objets – a incité les industriels à intégrer des produits initialement peu communicants dans des environnements en réseau. Cette intégration nécessite des protocoles de communication hérités de l’informatique grand public, et donc d’inté-grer des couches logicielles supportant ces protocoles. Le cas peut se révéler semblable pour des automates programmables (PLC) que l’on doit interfacer avec le réseau informatique d’une entreprise.

Et l’IoT dans tout ça ?Karim Yaghmour (grand spécialiste des systèmes embarqués Linux et Android) défi -nit l’IoT avec le sens de l’humour qui le caractérise.

IoT is the new hip way of talking about « embedded systems », something that’s been around for about 50+ years.

À l’heure actuelle, il n’est pas une publication (spécialisée ou non) qui n’évoque l’Internet des objets ( IoT). Même si l’on est loin d’une révolution, le concept de


http://kadionik.vvv.enseirb-matmeca.fr/se/projets_avances/1617/rapport_sujet6_SE_1617.pdf

http://kadionik.vvv.enseirb-matmeca.fr/se/projets_avances/1617/rapport_sujet6_SE_1617.pdf


l’IoT n’est pas seulement un terme marketing, mais correspond à l’association des techniques de l’embarqué – little data – et du big data (système d’information et cloud).

DÉJÀ EN 1995 !

Avec la notion d’IoT, nous rejoignons ici le concept des milliards de nœuds prédit par le chercheur français Christian Huitema dans son ouvrage de vulgarisation Et Dieu créa l’Internet (Éditions Eyrolles, 1995) : « Il y a déjà des microprocesseurs, en fait de tout petits ordinateurs dans bien d’autres endroits [...]. D’ici quelques années, le développement et les progrès de l’électronique aidant, ces microprocesseurs deviendront sans doute de vrais ordinateurs élaborés et il sera tout à fait raisonnable de les connecter à Internet. »

La mise en place de solutions IoT sur la base de composants libres – approche que nous défendons – pourrait constituer un ouvrage passionnant. L’auteur a d’ailleurs rédigé un livre blanc sur le sujet disponible sur http://www.systematic-paris-region.org/fr/node/22803. Pour montrer sa bonne foi sur le sujet, ce même auteur propose à la fi n de l’ouvrage une étude de cas sur le thème de l’IoT. Un capteur de température sous Linux (Raspberry Pi Zero W utilisant Yocto) envoie une trame de données vers un serveur en utilisant le protocole MQTT. Les valeurs peuvent être visualisées grâce à une application Android.

Tour d’horizon des systèmes d’exploitation existantsNous allons terminer ce chapitre par un rapide tour d’horizon des principaux sys-tèmes d’exploitation utilisés dans les environnements embarqués, à l’exception des systèmes à base de Linux, qui occuperont le reste de l’ouvrage !

FreeRTOSSelon les statistiques, FreeRTOS est à ce jour le système d’exploitation (RTOS) le plus utilisé dans l’industrie. Il est totalement open source et existe également dans une version commerciale avec support nommée OpenRTOS (voir http://www.freertos.org/a00114.html).


http://www.systematic-paris-region.org/fr/node/22803

http://www.systematic-paris-region.org/fr/node/22803

http://www.freertos.org/a00114.html

http://www.freertos.org/a00114.html

6 Linux embarqué

VxWorksMalgré la forte poussée des systèmes libres comme FreeRTOS, VxWorks est proba-blement encore aujourd’hui un des RTOS les plus utilisés dans l’industrie (en nombre de licences installées). Il est développé par la société Wind River (http://www.windriver.com). VxWorks est très fréquemment utilisé dans le cas de systèmes embarqués contraints, car certaines versions sont conformes à la norme ARINC 653 déjà citée. Il est cependant peu utilisé dans les systèmes grand public, car peu adapté au multi-média. Depuis quelques années, l’éditeur Wind River a cependant entrepris un virage vers le logiciel libre et les outils de développement sont désormais utilisables pour VxWorks et Linux. La version maison de Linux est nommée Wind River Linux, et Wind River – désormais rattachée à Intel – est un contributeur majeur du noyau Linux et du projet Yocto.

QNXDéveloppé par la société canadienne QNX Software (http://www.qnx.com), QNX est un noyau temps réel de type UNIX-like très intéressant. Il est conforme à POSIX et intègre un environnement graphique proche de X Window System. Conscient de la percée de Linux dans le monde de l’embarqué, QNX Software s’en est rapproché en mettant à disposition la majorité des outils GNU sur sa plate-forme. Très modulaire, il peut occuper une très faible empreinte mémoire et, de ce fait, être utilisé dans des environnements peu coûteux en matériel. QNX connaît de nos jours un nouveau gros succès dans l’automobile, secteur très actif de l’industrie de l’embarqué.

µC/OS II (micro-C/OS II)Développé par le canadien Jean J. Labrosse, µC/OS II est destiné à des environne-ments de très petite taille comme les microcontrôleurs. Il est maintenant disponible sur un grand nombre de processeurs et peut intégrer des protocoles standards comme TCP/IP (µC/IP). Il est utilisable gratuitement pour l’enseignement et de nombreuses informations sont disponibles sur https://www.micrium.com.

Windows EmbeddedMicrosoft est (était) présent sur de nombreux domaines du logiciel embarqué grâce à plusieurs versions compactes de Windows. La société a également investi dans la téléphonie mobile avec Windows Phone, chargé de concurrencer iOS et Android. Le désengagement de Microsoft dans les activités liées à l’embarqué et au mobile est de notoriété publique. Cependant, le lecteur intéressé par le sujet pourra contacter des spécialistes reconnus comme la société parisienne THEORIS (http://www.theoris.fr).



LynxOS LynxOS est développé par la société LynuxWorks (http://www.lynuxworks.com), qui a modifi é son nom il y a quelques années en raison de son virage vers Linux et le développement de BlueCat. LynxOS est un système temps réel conforme à la norme POSIX.

Nucleus Nucleus est développé par la société Mentor Graphics (https://www.mentor.com/embedded- soft ware/nucleus). C’est un noyau temps réel qui inclut une interface graphique (Grafi x), un navigateur web (WebBrowse), ainsi qu’un serveur HTTP (WebServ). Nucleus est fréquemment utilisé dans les terminaux bancaires de paiement électronique (TPE).

VRTXCe système assez ancien est connu pour équiper le télescope spatial Hubble. Il permet de gérer des processus contraints en mettant en place un système de partitionnement spatial (rien à voir avec Hubble !) et temporel.

eCosAcronyme pour embeddable Confi gurable operating system, eCos fut initialement développé par la société Cygnus (Cygnus, Your GNU Support), fi gure emblématique annonçant l’open source professionnel, acquise ensuite par la société Red Hat Soft-ware. C’est un système d’exploitation temps réel bien adapté aux solutions à très faible empreinte mémoire et profondément enfouies. Son environnement de développe-ment est basé sur Linux, et la chaîne de compilation GNU est conforme au standard POSIX. Argument non négligeable, il est diffusé sous une licence proche de la GPL et disponible avec ses sources sur http://ecos.sourceware.org. Le système eCos est utilisé dans l’industrie automobile, dans certaines imprimantes laser ou des produits multi-médias comme le casque ZIK de Parrot. Il est disponible pour un grand nombre de processeurs comme les x86, PowerPC, SHx et ARM.

Contiki Contiki (http://www.contiki-os.org) est un système d’exploitation libre très utilisé pour l’IoT et développé depuis 2002 par le Swedish Institute of Computer Science (SICS). Le système est diffusé sous licence BSD. Il est léger, fl exible et dispose d’une plate-forme de simulation (Cooja). Ce système est bien adapté aux capteurs, car il occupe quelques dizaines de kilo-octets et peut fonctionner sur des processeurs 8 à 32 bits. Un ouvrage


8 Linux embarqué

en ligne concernant l’utilisation de Contiki dans l’IoT est disponible sur http://wireless.ictp.it/school_2016/book/IoT_in_fi ve_days-v1.0.pdf.

RIOT RIOT (https://riot-os.org) est également un système d’exploitation libre dédié à l’IoT. Diffusé sous licence LGPL, son développement a démarré en 2008 et il est maintenu par l’INRIA. Tout comme Contiki, il peut fonctionner avec une très faible empreinte mémoire (1,5 kilo-octets) sur des plates-formes de 8 à 32 bits (plus de 80 cartes prises en charge, dont une émulation sous QEMU/x86). C’est un RTOS qui supporte le multi-threading, le protocole 6LoWPAN. Autre point important, il dispose d’une API POSIX. Il a fait l’objet de deux articles dans Open Silicium (numéros 18 et 19).

ConclusionCe chapitre a rappelé brièvement quelles étaient les applications et les contraintes liées aux systèmes embarqués. Dans le chapitre suivant, nous ferons quelques rappels sur le logiciel libre et Linux, et nous verrons dans quels cas il est possible de l’utiliser pour des solutions embarquées.


http://wireless.ictp.it/school_2016/book/IoT_in_five_days-v1.0.pdf

http://wireless.ictp.it/school_2016/book/IoT_in_five_days-v1.0.pdf

Documents

Un ouvrage de référence entièrement remis à jour P ...Linux embarqué Mise en place et développement Un ouvrage de référence entièrement remis à jour Depuis plus de 15 ans,