Chapitre 1.
Introduction à Yocto et au concept d'abstraction

1.1 Abstraction et le projet Yocto
1.2 Yocto et les méthodes d'apprentissage futures
1.3 Projet Yocto
1.4 Fichiers d'installation requis pour la pratique
1.5 Résumé

Chapitre 2.
bitbake

2.1 Obtenir le code source de Bitbake
2.2 Métadonnées
2.3 Fichiers de métadonnées
2.4 Bitbake Grammaire d'abord
2.5 Exécution de bitbake
2.6 Imprimer « Bonjour ! monde bitbake ! » avec bitbake
2.7 Interprétation des métadonnées générées jusqu'à présent
2.8 Exemple de procédure d'exécution de bitbake
2.9 Ajout d'une tâche à l'aide de la directive addtask
2.10 Résumé

Chapitre 3.
Exigu

3.1 OpenEmbedded
3.2 Téléchargez le code source de Poky et exécutez la compilation.
3.3 L'exécution de la compilation aboutit à l'émulateur QEMU
3.4 Vérification des valeurs des variables via les options des variables d'environnement bitbake
3.5 Comparaison du processus de construction du logiciel pour les hôtes Linux et du processus de construction pour le système de construction OpenEmbedded.
3.6 Résumé

Chapitre 4.
Travailler à améliorer la vitesse de construction

4.1 Obtention de la source
4.2 Configuration de votre propre dépôt source PREMIRRORS
4.3 Création de votre propre cache d'état partagé
4.4 Résumé

Chapitre 5.
Créez un nouveau calque et créez une recette

5.1 Exemples d'écriture pour pratiquer la grammaire
5.2 Grammaire Bitbake, partie 2
5.3 Écrire une recette pour une application Hello
5.4 Licence
Fichier d'extension de recettes 5.5
5.6 Rôle des variables BBFILE_COLLECTIONS et BBFILE_PATTERN
5.7 Résumé

Chapitre 6.
Ajout d'un gestionnaire d'initialisation et débogage via les fichiers journaux

6.1 Ajout d'un gestionnaire d'initialisation systemd
6.2 Débogage avec les journaux
6.3 Résumé

Chapitre 7.
Optimisez vos builds grâce aux fonctionnalités utiles des classes de base d'OpenEmbedded.

7.1 Création de l'éditeur nano à l'aide d'Autotools
7.2 Historique de la construction
7.3 Réduction de l'espace disque avec rm-work
7.4 Génération de code source à partir de sources externes à l'aide de externalsrc
7.5 Résumé

Chapitre 8.
Dépendance

8.1 Types de dépendances
8.2 FOURNIT une variable dans les recettes qui fournissent des dépendances
8.3 Résumé

Chapitre 9.
Création de groupes de packages et d'environnements de construction

9.1 Variables IMAGE_INSTALL et IMAGE_FEATURES
9.2 Groupe d'emballage
9.3 Groupes de paquets prédéfinis
9.4 Création d'un environnement de compilation avec un script de compilation personnalisé
9.5 Résumé

Chapitre 10.
Création d'une image personnalisée et d'une couche BSP basée sur la distribution Poky

10.1 Création d'une recette d'image personnalisée
Couche BSP 10.2
10.3 Grammaire Bitbake Partie 3
10.4 Création d'une couche BSP personnalisée
10.5 Résumé

Chapitre 11.
Recette de grains

11.1 Configuration du noyau
11.2 Créer des correctifs pour les options d'environnement du noyau modifiées ou ajoutées.
11.3 Créez un correctif pour le code source du noyau modifié ou ajouté.
11.4 Ajoutez les fichiers de correctif et de fragment de configuration générés à la recette du noyau.
11.5 Modification du code à l'aide de devshell
11.6 Métadonnées du noyau
11.7 Configuration des recettes de noyau non Linux Yocto
11.8 Résumé

Chapitre 12.
Extension des recettes à base de noyau

12.1 Utilisation des sources du noyau local via la classe externalsrc
12.2 Utilisation du fichier defconfig dans le code source du noyau
12.3 Création de modules noyau en dehors du code source du noyau
12.4 Installation des modules du noyau à l'aide des variables MACHINE_EXTRA_RDEPENDS et MACHINE_ESSENTIAL_EXTRA_RDEPENDS
12.5 Résumé

Chapitre 13.
Couche de distribution

13.1 Couche de distribution
13.2 Création de votre propre couche de distribution
13.3 Différences entre DISTRO_FEATURES, IMAGE_FEATURES et MACHINE_FEATURES.391
13.4 Résumé

Chapitre 14.
Couche client

14.1 Création d'une couche client
14.2 Résumé du Grand Système
14.3 Résumé

Chapitre 15.
Emballer

15.1 Tâches d'empaquetage pendant le processus de compilation
Ensemble 15,2 tr/min
15,3 miam
15.4 Exercices pratiques de création de bibliothèques
15.5 Amélioration du package de génération de bibliothèque
15.6 Résumé

Chapitre 16.
Les tâches do_rootfs et do_image exécutent le processus d'installation du paquet.

16.1 Tâche do_rootfs
16.2 Personnalisation du système de fichiers racine
16.3 Script de post-installation
16.4 Création de l'image finale en exécutant la tâche do_image
16.5 Résumé

Chapitre 17.
Cache d'état partagé et signatures

17.1 Cache d'état partagé
17.2 Signature
17.3 Optimisation du cache d'état partagé déjà créé
17.4 Résumé

Chapitre 18.
Kirkstone

18.1 Caractéristiques de Kirkstone
18.2 Installation de Kirkstone
Migration des exemples de la version 18.3 Dunfell vers Kirkstone
18.4 Résumé

Chapitre 19. SDK (Kit de développement logiciel)

19.1 Création d'un SDK
19.2 Création d'une application cible à l'aide du SDK installé
19.3 Création d'un module noyau cible à l'aide du SDK installé
19.4 chaîne de méta-outils
19.5 Résumé

Chapitre 20.
Autres sujets non abordés

20.1 Extensions des fonctions et variables Python
20.2 Fonctions Python anonymes
20.3 Bitbake Grammaire Quatrième
20.4 Utilisation de l'outil oe-pkgdata-util
20.5 Variables PACKAGECONFIG
20.6 Distribution du code source
20.7 Portage d'une couche déjà créée
20.8 Résumé

Chapitre 21.
outil de développement

21.1 Vue d'ensemble de Devtool
21.2 Création d'une application à l'aide de devtool
21.3 Création d'un module noyau à l'aide de devtool
21.4 Résumé

Annexe spéciale

Ce que ce livre couvre

- Explique les opérations de base de bitbake afin que les débutants puissent apprendre la structure et les concepts de Yocto.
-Décrit le fonctionnement de base du système de construction Open Embedded, y compris Open Embedded Core et Bitbake.
-Comment écrire du code pour les applications, les pilotes de noyau, etc. en utilisant Yocto
-Le concept de Kirkstone, la dernière version de Yocto, et comment migrer de la version Dunfell vers Kirkstone.
- Description et exemples des couches Yocto établies, basées sur une architecture en couches.
- Explications et exemples de paquets et de dépendances, la partie délicate de Yocto.
- Description et exemples de développement de packages à l'aide du SDK et des outils de développement
- Écriture de code simple et efficace grâce aux cœurs embarqués fournis par Yocto

Public cible de ce livre

- Un débutant qui s'est toujours intéressé à Yocto mais qui ne sait pas par où commencer ni comment étudier.
-Un praticien qui travaille avec Yocto mais qui ne sait que vaguement comment l'utiliser et qui ne connaît pas la structure et les principes généraux.
-Développeurs souhaitant créer des programmes Linux avec Yocto

Structure de ce livre

Dans le chapitre 1, nous apprendrons ce qu'est Yocto et comprendrons la signification de l'abstraction contenue dans Yocto.
Le chapitre 2 examine de plus près bitbake, le cœur du système de construction de Yocto.
Au chapitre 3, nous découvrons Poky, qui contient un système de construction embarqué ouvert.
Le chapitre 4 présente deux méthodes pour accélérer votre construction avant de commencer les exercices pratiques.
Vous apprendrez donc à configurer vos propres PREMIRRORS et votre cache d'état partagé.
Au chapitre 5, vous créerez une nouvelle couche, écrirez votre propre fichier de recette et apprendrez la grammaire associée.

Au chapitre 6, nous apprendrons comment exécuter le fichier binaire de l'application créé au chapitre 5 dans le système d'initialisation systemd, et nous apprendrons également à le déboguer.
Le chapitre 7 traite des méthodes d'optimisation de la compilation à l'aide des classes fournies par Open Embedded Core.
Apprenez à créer facilement des applications à l'aide d'Autotools, d'externalsrc pour localiser les sources localement, de rm_work pour supprimer les artefacts de compilation inutiles et de la classe buildhistory pour stocker les informations de compilation.
Le chapitre 8 traite des dépendances entre les recettes et les paquets.
Les dépendances comprennent les dépendances de compilation et les dépendances d'exécution, que nous examinerons en détail.
Au chapitre 9, nous découvrirons les groupes de paquets et mettrons en place notre propre environnement de compilation pour les exercices futurs.
À partir du chapitre 10, nous créerons des images personnalisées et des couches BSP personnalisées basées sur la distribution Poky.
Ce contenu s'apprend selon une architecture en couches.
En créant les différentes couches une à une, nous comprendrons le travail réellement effectué sur le terrain.

Au chapitre 11, nous découvrons les recettes à base de grains.
Le système de construction embarqué ouvert fournit des classes qui vous aident à compiler facilement des noyaux.
Cette classe vous permet d'appliquer facilement des correctifs et des options de configuration.
Nous aborderons également les métadonnées du noyau fournies par Yocto.
Au chapitre 12, nous développons la recette du noyau que nous avons apprise au chapitre 11 et ajoutons davantage de fonctionnalités.
Nous apprendrons également comment stocker les sources du noyau en externe en héritant de la classe externalsrc et comment utiliser le fichier defconfig dans la source du noyau.
Vous apprendrez également à compiler des modules du noyau en dehors de l'arborescence source du noyau.
Au chapitre 13, nous découvrons la couche de distribution.
Cela nous permet de comprendre que la couche de déploiement a des préférences pour les builds selon les déploiements.
Et créez votre propre couche de distribution pour approfondir votre compréhension de cette couche.
Au chapitre 14, nous allons créer la couche client, la couche supérieure de l'architecture en couches, afin de comprendre comment ajouter et modifier du code basé sur Yocto distribué par les fournisseurs de puces dans des applications réelles.
Au chapitre 15, nous découvrons les colis.
Pour intégrer les résultats créés dans un environnement de compilation croisée dans une cible réelle, ils doivent être empaquetés.
Pour comprendre les packages, nous allons également apprendre à créer des bibliothèques partagées.

Au chapitre 16, nous apprendrons le processus d'installation du paquet.
Vous apprendrez à créer le système de fichiers racine, c'est-à-dire l'image qui sera finalement créée.
Le chapitre 17 détaille davantage le cache d'état partagé que nous avons construit au chapitre 4, et nous apprenons également comment optimiser le cache d'état partagé.
Au chapitre 18, nous découvrons Kirkstone, la version de Yocto bénéficiant d'un support à long terme.
Découvrez les caractéristiques uniques de Kirkstone et installez un véritable Kirkstone.
Et transférons l'exemple précédemment écrit dans la version Dunfell vers Kirkstone.
Au chapitre 19, nous découvrons le SDK.
Étant donné que le SDK est utilisé comme environnement de développement lors du développement d'applications ou de modules de noyau externes, apprenez à créer un SDK.
Ensuite, installez le SDK généré sur l'hôte et créez une application et un module noyau externe à l'aide du SDK généré.
Le chapitre 20 traite des fonctions Python, des fonctions Python anonymes et de la syntaxe bitbake.
Vous apprendrez également à utiliser l'outil oe-pkgdta-util, à configurer les builds fonctionnalité par fonctionnalité à l'aide de la variable PACKAGECONFIG, à distribuer le code source fourni par OpenEmbeddedCore et à porter et utiliser des couches pré-compilées dans votre projet actuel.
Au chapitre 21, nous en apprenons davantage sur devtool.
Auparavant, lors de la création d'un nouveau package, nous créions une couche, rédigions une recette, ajoutions la recette au fichier layer.conf et ajoutions le package à la recette d'image.
La réalisation de ce processus nécessite un certain effort et des connaissances de base de Yocto.
Cependant, l'utilisation de devtool réduit les efforts et vous permet de développer facilement des applications ou des modules de noyau même sans connaissances de base de Yocto.
Par conséquent, au chapitre 21, nous apprendrons le concept de devtool et comment l'utiliser à travers des exemples simples.

Note de l'auteur

La vie d'un développeur semble très difficile.
Car, dans cette ère de changements rapides, il y a tant de choses à apprendre et à savoir.
Surtout si vous vous lancez dans le développement Linux, vous vous rendrez compte que le processus est loin d'être facile.
Lorsqu'on examine le code Linux, on peut souvent être submergé par son immensité et sa structure.
La simple connaissance du langage C ne suffit pas à faire ressortir le code Linux, et de nos jours, il faut également apprendre Python, C++, Rust et d'autres langages, ce qui rend l'interprétation du code très lente.

Lorsque j'ai découvert Yocto, j'ai écrit un code rudimentaire qui s'exécutait en référençant du code écrit par d'autres développeurs, mais je ne comprenais pas pourquoi il fallait procéder ainsi ni dans quel ordre les instructions seraient exécutées.
Par exemple, il fut un temps où tout ce que je savais sur l'écriture d'un pilote Linux se résumait à « écrire l'adresse en amont dans SRC_URI, placer le code de manière à ce qu'il puisse être compilé dans do_compile et le déployer dans do_install ».
De ce fait, l'amélioration des fonctionnalités souhaitées ou la prise en compte de nouvelles idées ont été reléguées au second plan, et la triste réalité de devoir adapter le code aux limites de connaissances de base restreintes s'est imposée.

En tant que développeur, vous devez structurer et créer le code comme vous le souhaitez.
Par conséquent, je pense que les développeurs ayant le même niveau que moi à l'époque ont la responsabilité d'approfondir leurs connaissances de Yocto afin d'éviter qu'un tel incident regrettable ne se reproduise.
Si certains sont frustrés de ne pas bien connaître Yocto comme je le faisais à l'époque, je voudrais leur dire qu'il est temps de prendre le temps d'apprendre les concepts de base et l'utilisation de Yocto.
Il y a une phrase que j'aime bien, tirée d'un livre d'un youtubeur populaire, intitulée « La vie est une bataille ».
Ne vous inquiétez pas de vieillir, ne vous inquiétez pas de commencer trop tard, ne vous inquiétez pas de ne pas bien faire les choses.
Il n'est jamais trop tard dans ce monde.
« Il n’y a dans le monde que la “complétude” et l’“incomplétude”. »