<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Pierre FICHEUX on Medium]]></title>
        <description><![CDATA[Stories by Pierre FICHEUX on Medium]]></description>
        <link>https://medium.com/@pierre.ficheux?source=rss-968911f3bc20------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wrW3ki4ppPu3tGSQE99ptQ.png</url>
            <title>Stories by Pierre FICHEUX on Medium</title>
            <link>https://medium.com/@pierre.ficheux?source=rss-968911f3bc20------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 17:43:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pierre.ficheux/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Introduction à Yocto (partie 2)]]></title>
            <link>https://medium.com/smileinnovation/introduction-%C3%A0-yocto-partie-2-38d979843cb7?source=rss-968911f3bc20------2</link>
            <guid isPermaLink="false">https://medium.com/p/38d979843cb7</guid>
            <category><![CDATA[connected-devices]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[embedded-systems]]></category>
            <category><![CDATA[iot]]></category>
            <dc:creator><![CDATA[Pierre FICHEUX]]></dc:creator>
            <pubDate>Fri, 20 Apr 2018 09:46:24 GMT</pubDate>
            <atom:updated>2018-04-20T09:46:24.111Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*gqaK0--azExuARp3R4LtgA.jpeg" /></figure><p><em>Dans </em><a href="https://medium.com/smileinnovation/introduction-%C3%A0-yocto-db56a550ae51"><em>un premier article</em></a><em> nous avons introduit les principes de Yocto et décrit comment produire une image de test pour des cibles QEMU (x86) et Raspberry Pi 3. Dans ce deuxième article nous allons nous attacher à l’ajout puis à la création de « recettes » permettant d’étendre les possibilités de l’image produite. La lecture du premier article est bien entendu nécessaire à la compréhension de ce deuxième volet.</em></p><h3>Étendre l’image produite</h3><p>Nous avions vu que la méthode de production de l’image était la même quelle que soit la cible choisie (dans notre cas QEMU/x86 et Raspberry Pi 3). Nous avions choisi de construire l’image la plus simple soit « core-image-minimal » par les commandes suivantes dans le cas de la Pi 3.</p><pre>$ cd &lt;Yocto-src-path&gt;<br>$ source oe-init-build-env rpi3-build<br>$ bitbake core-image-minimal</pre><p>Le test de l’image dépend de la cible choisie puisque un test QEMU/x86 se résume à l’appel de l’émulateur (soit runqemu qemux86) alors qu’un test sur cible réelle nécessite de copier l’image produite sur une mémoire flash (ou un disque dur). Dans le cas de la Raspberry Pi 3, nous pouvons créé une Micro-SD par les commandes suivantes.</p><pre>$ umount /dev/mmcblk0p*<br>$ sudo dd if=tmp/deploy/image/raspberrypi3/core-image-minimal-raspberrypi3.rpi-sdimg of=/dev/mmcblk0</pre><p>L’image actuelle est réduite au strict minimum car elle n’inclut pas les modules du noyau Linux et ne dispose pas de système de gestion de paquets. De ce fait la taille de l’image produite est très faible (56 Mo pour l’image complète).</p><pre>$ ls -lLh tmp/deploy/images/raspberrypi3/core-image-minimal-raspberrypi3.rpi-sdimg <br>-rw-r — r — 1 pierre pierre <strong>56M</strong> avril 11 15:25 tmp/deploy/images/raspberrypi3/core-image-minimal-raspberrypi3.rpi-sdimg</pre><p>Il est donc judicieux d’étendre l’image en ajoutant d’autres paquets ou fonctionnalités. Dans un premier temps il est tout à fait possible de réaliser cela en modifiant le fichier conf/local.conf. A titre d’exemple nous pouvons ajouter un serveur SSH nommé Dropbear en ajoutant la ligne suivante au fichier conf/local.conf . Cette ligne indique d’ajouter à l’image finale le résultat de la construction de la recette correspondante. Cette recette est déjà fournie par Yocto dans le répertoire meta/recipes-core/dropbear.</p><pre>IMAGE_INSTALL_append = “ dropbear”</pre><p>Nous avions vu que la construction de la recette passait par différentes étapes en partant du téléchargement des sources jusqu’à la création du paquet binaire. Notre image ne disposant pas de système de gestion de paquets, le nouveau composant est ajouté à l’image de manière statique (comme on le ferait avec Buildroot). Le paquet est cependant créé sur le poste de développement comme l’indique la commande suivante.</p><pre>$ ls -l tmp/deploy/ipk/cortexa7hf-neon-vfpv4/dropbear*<br>-rw-r — r — 2 pierre pierre 119004 avril 11 15:38 tmp/deploy/ipk/cortexa7hf-neon-vfpv4/dropbear_2017.75-r0_cortexa7hf-neon-vfpv4.ipk<br>-rw-r — r — 2 pierre pierre 881666 avril 11 15:38 tmp/deploy/ipk/cortexa7hf-neon-vfpv4/dropbear-dbg_2017.75-r0_cortexa7hf-neon-vfpv4.ipk<br>-rw-r — r — 2 pierre pierre 832 avril 11 15:38 tmp/deploy/ipk/cortexa7hf-neon-vfpv4/dropbear-dev_2017.75-r0_cortexa7hf-neon-vfpv4.ipk</pre><p>Nous verrons plus tard pourquoi il existe trois paquets binaires pour une seule recette (soit des paquets -dbg et -dev en plus du paquet principal). La commande suivante indique quels sont les composants installés par le paquet binaire. Le format IPK étant proche du format DEB utilisé sur Debian/Ubuntu, le contenu du paquet est visible grâce à la commande dpkg.</p><pre>$ dpkg -c tmp/deploy/ipk/cortexa7hf-neon-vfpv4/dropbear_2017.75-r0_cortexa7hf-neon-vfpv4.ipk <br>drwxrwxrwx root/root 0 2018–04–11 15:38 ./<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./etc/<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./etc/default/<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./etc/dropbear/<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./etc/init.d/<br>-rwxr-xr-x root/root 2168 2018–04–11 15:38 ./etc/init.d/dropbear<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./var/<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./usr/<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./usr/sbin/<br>-rwxr-xr-x root/root 224168 2018–04–11 15:38 ./usr/sbin/dropbearmulti<br>lrwxrwxrwx root/root 0 2018–04–11 15:38 ./usr/sbin/dropbearconvert -&gt; ./dropbearmulti<br>lrwxrwxrwx root/root 0 2018–04–11 15:38 ./usr/sbin/dropbear -&gt; ./dropbearmulti<br>lrwxrwxrwx root/root 0 2018–04–11 15:38 ./usr/sbin/dropbearkey -&gt; ./dropbearmulti<br>drwxr-xr-x root/root 0 2018–04–11 15:38 ./usr/bin/<br>lrwxrwxrwx root/root 0 2018–04–11 15:38 ./usr/bin/dbclient -&gt; /usr/sbin/dropbearmulti</pre><p>Au démarrage de la nouvelle image, nous constatons l’initialisation et le démarrage de Dropbear.</p><pre>Starting Dropbear SSH server: Generating key, this may take a while… </pre><p>Outre l’ajout de recettes, nous avions vu dans le premier article qu’il était possible d’ajouter des « features » comme la prise en compte des paquets binaires. Cette fonctionnalité est indispensable si nous voulons tester le développement et l’ajout dynamique de recette. <br>Pour ce faire nous ajoutons la ligne suivante au fichier conf/local.conf et nous construisons de nouveau l’image. Notons que nous avons commenté la ligne concernant le serveur Dropbear car nous l’ajouterons a posteriori en utilisant le système de gestion de paquets. Notons également qu’il est nécessaire de spécifier le format IPK car Yocto utilise par défaut le format RPM. Nous avons également augmenté la taille du root-filesystem de 50 Mo afin de pouvoir manipuler quelques paquets binaires.</p><pre>EXTRA_IMAGE_FEATURES = “package-management”<br>PACKAGE_CLASSES = “package_ipk”<br>IMAGE_ROOTFS_EXTRA_SPACE = “50000”<br><strong>#IMAGE_INSTALL_append = “ dropbear”</strong></pre><p>Dans la suite de l’article nous partirons du principe que l’image utilise cette configuration. Au démarrage du système, celui-ci doit disposer de la commande opkg.</p><pre>root@raspberrypi3:~# type opkg <br>opkg is a tracked alias for /usr/bin/opkg </pre><h3>Configurer le gestionnaire de paquets</h3><p>Le gestionnaire de paquets utilise la base des paquets binaires présente sur le poste de développement dans le répertoire tmp/deploy/ipk. Comme nous l’avions vu dans le premier article, ce répertoire contient trois sous-répertoires correspondant aux trois types de paquets (indépendant de l’architecture, spécifique à à l’architecture, spécifique à la cible).</p><pre>$ ls -l tmp/deploy/ipk/<br>total 568<br>drwxr-xr-x 2 pierre pierre 4096 avril 11 16:33 all<br>drwxr-xr-x 2 pierre pierre 372736 avril 11 16:33 cortexa7hf-neon-vfpv4<br>drwxr-xr-x 2 pierre pierre 196608 avril 11 16:33 raspberrypi3</pre><p>En premier lieu on doit construire l’index à partir de la liste des paquets.</p><pre>$ bitbake package-index</pre><p>On peut alors donner accès au répertoire par le protocole HTTP. Dans le cas de notre test, on peut utiliser le mini-serveur HTTP intégré à Python qui utilise le port 8000.</p><pre>$ cd tmp/deploy/ipk/<br>$ python -m SimpleHTTPServer<br>Serving HTTP on 0.0.0.0 port 8000 …</pre><p>Du coté de la cible on doit modifier le fichier<em> </em>/etc/opkg/opkg.conf<em> </em>afin d’ajouter les caractéristiques du serveur. En supposant que l’adresse IP du PC de développement est 192.168.1.23, on ajoute les lignes suivantes au fichier.</p><pre>src/gz all <a href="http://192.168.1.23:8000/all">http://192.168.1.23:8000/all</a> <br>src/gz cortexa7hf-neon-vfpv4 <a href="http://192.168.1.23:8000/cortexa7hf-neon-vfpv4">http://192.168.1.23:8000/cortexa7hf-neon-vfpv4</a> <br>src/gz raspberrypi3 <a href="http://192.168.1.23:8000/raspberrypi3">http://192.168.1.23:8000/raspberrypi3</a> </pre><p>On peut alors mettre à jour l’index des paquets sur la cible.</p><pre>root@raspberrypi3:~# opkg update</pre><p>Cette commande a pour effet d’afficher les traces suivantes dans la fenêtre du serveur HTTP, l’adresse IP de la carte étant 192.168.1.16.</p><pre>192.168.1.16 - - [11/Apr/2018 16:34:18] &quot;GET /all/Packages.gz HTTP/1.1&quot; 200 -<br>192.168.1.16 - - [11/Apr/2018 16:34:18] &quot;GET /cortexa7hf-neon-vfpv4/Packages.gz HTTP/1.1&quot; 200 -<br>192.168.1.16 - - [11/Apr/2018 16:34:18] &quot;GET /raspberrypi3/Packages.gz HTTP/1.1&quot; 200 -</pre><p>On peut alors utiliser quelques options de la commande opkg. En premier lieu on peut obtenir la liste des paquets installés.</p><pre>root@raspberrypi3:~# opkg list-installed</pre><p>On peut ensuite afficher le contenu d’un paquet particulier.</p><pre>root@raspberrypi3:~# opkg files busybox <br>Package busybox (1.24.1-r0) is installed on root and has the following files: <br>/bin/sh <br>/bin/busybox.suid <br>/bin/busybox <br>/etc/busybox.links.nosuid <br>/etc/busybox.links.suid <br>/bin/busybox.nosuid</pre><p>On peut également rechercher le paquet Dropbear et l’installer dynamiquement sur la cible. Le paquet est configuré lors de l’installation.</p><pre>root@raspberrypi3:~# opkg list | grep dropbear <br>dropbear — 2017.75-r0 — A lightweight SSH and SCP implementation <br>dropbear-dbg — 2017.75-r0 — A lightweight SSH and SCP implementation — Debugging files <br>dropbear-dev — 2017.75-r0 — A lightweight SSH and SCP implementation — Development files</pre><pre>root@raspberrypi3:~# opkg install dropbear <br>Installing dropbear (2017.75) on root <br>Downloading <a href="http://192.168.1.23:8000/cortexa7hf-neon-vfpv4/dropbear_2017.75-r0_c">http://192.168.1.23:8000/cortexa7hf-neon-vfpv4/dropbear_2017.75-r0_c</a><br>ortexa7hf-neon-vfpv4.ipk</pre><h3>Créer des recettes</h3><p>Nous pouvons maintenant nous attacher à créer quelques recettes simples que nous pourrons ajouter à notre environnement Yocto puis à notre cible. Une recette est un fichier<em> </em>.bb (pour <em>BitBake</em>) utilisant un syntaxe décrivant des métadonnées. Les directives de la recette sont exécutées par la commande bitbake. La notion de recette est utilisée quelle que soit la complexité du composant (un simple exemple « Hello World », l’outil BusyBox, le noyau Linux et même l’image du système).</p><pre>$ cd meta<br>$ ls recipes-core/images<br>build-appliance-image core-image-minimal-dev.bb<br>build-appliance-image_15.0.0.bb core-image-minimal-initramfs.bb<br>core-image-base.bb core-image-minimal-mtdutils.bb<br>core-image-minimal.bb core-image-tiny-initramfs.bb<br>recipes-core/images/core-image-minimal.bb</pre><pre>$ ls recipes-core/busybox<br>busybox busybox-1.24.1 busybox_1.24.1.bb busybox.inc files</pre><p>La recette du noyau est fournie par la couche (layer) BSP externe à Yocto et disponible auprès du fabricant de la carte ou d’une communauté de développement (comme c’est le cas pour la Raspberry Pi).</p><pre>$ cd ../meta-raspberrypi<br>$ ls recipes-kernel/linux<br>linux-raspberrypi_4.9.bb linux-raspberrypi-dev.bb linux-raspberrypi.inc</pre><p>Comme nous pouvons le constater, une recette est toujours associée à un layer (meta, meta-raspberrypi, meta-&lt;nom-de-layer) dans un sous-répertoire de type recipes-*/&lt;nom-de-recette&gt;.</p><h4>Les différents type de recettes</h4><p>Nous pouvons classifier (grossièrement) les recettes en quelques types bien identifiés. Ces types sont déduits des outils utilisés pour la production des projets libres dans un environnement de type UNIX/Linux (même si ces outils existent également pour d’autres systèmes d’exploitation).</p><ul><li>Utilisation de l’outil Autotools³</li><li>Utilisation de l’outil CMake⁴</li><li>Plus rarement, utilisation de la commande make et d’un fichier Makefile</li></ul><p>Il n’est bien entendu pas envisageable de décrire les outils Autotools et CMake dans le cadre de cet article et nous renvoyons donc le lecteur aux entrées de bibliographie. Ces outils sont prévus pour permettre la compilation (croisée ou non) d’un projet sur (et à destination de) différents types de systèmes. L’utilisation d’un simple Makefile est un peu « démodée » car ce dernier ne prend pas automatiquement en compte les caractéristiques des systèmes comme le font Autotools et CMake.<br>Yocto permet de créer des recettes sans réellement se préoccuper du fonctionnement de ces outils en utilisant la notions de classe. Les principales classes disponibles sont localisées dans le répertoire meta/classes sous la forme de fichiers .class. A titre d’exemple, le fichier suivant correspond à la classe permettant de traiter les sources basées sur Autotools.</p><pre>$ ls -l meta/classes/autotools.bbclass <br>-rw-rw-r — 1 pierre pierre 8798 févr. 9 22:25 meta/classes/autotools.bbclass </pre><p>Comme nous le verrons dans les exemples qui suivent, on peut utiliser une classe en invoquant simplement la directive inherti &lt;nom-de-classe&gt;dans le fichier de recette.</p><h4>Un exemple (très) simple</h4><p>Avant de décrire le format d’une recette nous allons utiliser l’outil yocto-layer<em> </em>fourni par Yocto afin de créer un layer de test meta-exampl. Outre la création du layer, yocto-layer permet d’ajouter automatiquement une recette de test au layer créé. Pour cela on utilise la commande suivante à partir du répertoire des sources de Yocto (ou même dans un répertoire quelconque).</p><pre>$ cd &lt;Yocto-src-path&gt;<br>$ yocto-layer create example</pre><pre>Please enter the layer priority you’d like to use for the layer: [default: 6] <br>Would you like to have an example recipe created? (y/n) [default: n] <strong>y</strong><br>Please enter the name you’d like to use for your example recipe: [default: example] <br>Would you like to have an example bbappend file created? (y/n) [default: n]</pre><pre>New layer created in meta-example.</pre><pre>Don’t forget to add it to your BBLAYERS (for details see meta-example/README).</pre><p>Une nouvelle recette nommée <em>example</em> est créée dans l’arborescence. La recette est constituée du fichier .bb ainsi que d’un répertoire contenant les données (dans notre cas les sources de l’exemple).</p><pre>meta-example/<br>├── conf<br>│   └── layer.conf<br>├── COPYING.MIT<br>├── README<br>└── recipes-example<br>    └── <strong>example</strong><br>        ├── example-0.1<br>        │   ├── example.patch<br>        │   └── helloworld.c<br>        └── <strong>example_0.1.bb</strong></pre><p>Comme l’indique le dernier message produit par yocto-layer, on doit ajouter le nouveau layer à l’environnement de compilation. Cette action est réalisée par la commande bitbake-layers.</p><pre>$ cd rpi3-build <br>$ bitbake-layers add-layer ../meta-example</pre><p>Cette commande ajoute simplement le chemin d’accès du layer au fichier conf/bblayers.conf. On peut alors construire la recette (i.e. produire le paquet binaire).</p><pre>$ bitbake example<br>Les paquets sont disponibles dans le répertoire prévu.<br>$ ls -l tmp/deploy/ipk/cortexa7hf-neon-vfpv4/example*<br>-rw-r — r — 2 pierre pierre 2176 avril 11 18:27 tmp/deploy/ipk/cortexa7hf-neon-vfpv4/example_0.1-r0_cortexa7hf-neon-vfpv4.ipk<br>-rw-r — r — 2 pierre pierre 3960 avril 11 18:27 tmp/deploy/ipk/cortexa7hf-neon-vfpv4/example-dbg_0.1-r0_cortexa7hf-neon-vfpv4.ipk<br>-rw-r — r — 2 pierre pierre 732 avril 11 18:27 tmp/deploy/ipk/cortexa7hf-neon-vfpv4/example-dev_0.1-r0_cortexa7hf-neon-vfpv4.ipk</pre><p>Le paquet « principal » contient l’exécutable helloworld issu de la compilation du fichier<em> </em>helloworld.c.</p><pre>$ dpkg -c tmp/deploy/ipk/cortexa7hf-neon-vfpv4/example_0.1-r0_cortexa7hf-neon-vfpv4.ipk <br>drwxrwxrwx root/root 0 2018–04–11 18:27 ./<br>drwxr-xr-x root/root 0 2018–04–11 18:27 ./usr/<br>drwxr-xr-x root/root 0 2018–04–11 18:27 ./usr/bin/<br>-rwxr-xr-x root/root 5552 2018–04–11 18:27 ./usr/bin/helloworld</pre><p>Le paquet -dbgcontient une version de l’exécutable « débogable » sur la cible (en utilisant gdbserver). Le paquet -devest utile dans le cas des recettes de bibliothèques pour lesquelles il est nécessaire de disposer du fichier binaire (suffixé .so) sur la cible mais également dans l’environnement de développement croisé (SDK) produit par Yocto. Dans le cas d’un exécutable, ce paquet est bien entendu vide.<br>Avant d’installer le nouveau paquet sur la cible on doit mettre à jour l’index sur le PC de développement.</p><pre>$ bitbake package-index</pre><p>On doit également effectuer la mise à jour (update) de la liste sur la cible.</p><pre>root@raspberrypi3:~# opkg update <br>Downloading <a href="http://192.168.1.23:8000/all/Packages.gz">http://192.168.1.23:8000/all/Packages.gz</a>. <br>Updated source ‘all’. <br>Downloading <a href="http://192.168.1.23:8000/cortexa7hf-neon-vfpv4/Packages.gz">http://192.168.1.23:8000/cortexa7hf-neon-vfpv4/Packages.gz</a>. <br>Updated source ‘cortexa7hf-neon-vfpv4’. <br>Downloading <a href="http://192.168.1.23:8000/raspberrypi3/Packages.gz">http://192.168.1.23:8000/raspberrypi3/Packages.gz</a>. <br>Updated source ‘raspberrypi3’.</pre><p>On peut alors installer et tester le nouveau paquet.</p><pre>root@raspberrypi3:~# opkg install example <br>Installing example (0.1) on root <br>Downloading <a href="http://192.168.1.23:8000/cortexa7hf-neon-vfpv4/example_0.1-r0_cortex">http://192.168.1.23:8000/cortexa7hf-neon-vfpv4/example_0.1-r0_cortex</a><br>a7hf-neon-vfpv4.ipk. <br>Configuring example.</pre><pre>root@raspberrypi3:~# helloworld <br>Hello World!</pre><h4>Syntaxe du fichier de recette</h4><p>Après avoir installé le paquet nous allons décrire rapidement le format du fichier de recette. Les premières lignes décrivent le composant ainsi que la catégorie. Ces informations seront utilisées par le gestionnaire de paquets.</p><pre>SUMMARY = “Simple helloworld application”<br>SECTION = “examples”</pre><p>On déclare ensuite la licence des sources que l’on authentifie grâce à un checksum.</p><pre>LICENSE = “MIT”<br>LIC_FILES_CHKSUM = “file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302”</pre><p>La variable<em> </em>SRC_URI doit contenir la liste de tous les composants nécessaires à la construction du paquet. Dans notre cas la liste se limite à un fichier source local (d’où l’opérateur file://) présent dans le sous-répertoire example_0.1.</p><pre>SRC_URI = “file://helloworld.c”</pre><p>Les lignes suivantes décrivent la compilation du fichier source et l’installation de l’exécutable. Le fichier Makefile étant absent on doit décrire précisément comment réaliser ces opérations en invoquant les commandes nécessaires.</p><pre>S = “${WORKDIR}”</pre><pre>do_compile() {<br> ${CC} ${LDFLAGS} helloworld.c -o helloworld<br>}</pre><pre>do_install() {<br> install -d ${D}${bindir}<br> install -m 0755 helloworld ${D}${bindir}<br>}</pre><h4>Recettes Autotools et CMake</h4><p>Dans la réalité la plupart des projets utilisent Autotools, CMake ou plus rarement un simple fichier Makefile. Dans cette section nous allons voir comment écrire une recette en utilisant les classes Autotools et CMake, ce qui facilite grandement la tâche. <br>Considérons un exemple « Hello World » proche du précédent mais basé sur Autotools. Le contenu du fichier de recette est décrit ci-dessous.</p><pre>DESCRIPTION = “Helloworld software (autotools)”LICENSE = “GPLv2”<br>LIC_FILES_CHKSUM = “file://COPYING;md5=8ca43cbc842c2336e835926c2166c28b”</pre><pre>SRC_URI = “http://pficheux.free.fr/pub/tmp/mypack-auto-1.0.tar.gz&quot;</pre><pre><strong>inherit autotools</strong></pre><pre>SRC_URI[md5sum] = “b282082e4e5cc8634b7c6caa822ce440”</pre><p>La première différence avec le premier exemple est l’obtention des sources auprès d’un serveur externe (ce qui est le cas le plus fréquent). A partir du moment ou une archive externe est utilisée, on doit déclarer le checksum du fichier comme décrit dans la dernière ligne de la recette. Le traitement des sources est entièrement pris en charge par la classe et il suffit donc d’utiliser la directive inherit. <br>Le cas d’une recette basée sur CMake est identique en utilisant la classe correspondante.</p><pre>DESCRIPTION = “Helloworld software (CMake)”<br>LICENSE = “GPLv2”<br>LIC_FILES_CHKSUM = “file://COPYING;md5=8ca43cbc842c2336e835926c2166c28b”<br>PR = “r0”<br>SRC_URI = “http://pficheux.free.fr/pub/tmp/mypack-cmake-1.0.tar.gz&quot;</pre><pre><strong>inherit cmake</strong></pre><pre>SRC_URI[md5sum] = “70e89c6e3bff196b4634aeb5870ddb61”</pre><h3>Conclusion</h3><p>Ce deuxième article nous a permis d’effleurer les techniques de création des recettes Yocto ainsi que leur intégration dans une image. Le lecteur désirant aller plus loin pourra consulter l’ouvrage de l’auteur⁵ ou bien d’autres ouvrages dédiés à Yocto⁶.</p><h3>Bibliographie</h3><p><a href="https://www.yoctoproject.org/"><em>[1] Projet Yocto https://www.yoctoproject.org/<br></em></a><a href="http://www.yoctoproject.org/docs/2.4.1/ref-manual/ref-manual.html"><em>[2] Manuel de référence Yocto http://www.yoctoproject.org/docs/2.4.1/ref-manual/ref-manual.html</em></a><em><br></em><a href="https://www.lrde.epita.fr/~adl/autotools.html"><em>[3] Autotools tutorial (LRDE) https://www.lrde.epita.fr/~adl/autotools.html</em></a><em><br></em><a href="http://sirien.metz.supelec.fr/depot/SIR/TutorielCMake/index.html"><em>[4] Tutoriel CMake http://sirien.metz.supelec.fr/depot/SIR/TutorielCMake/index.html</em></a><em><br></em><a href="https://www.eyrolles.com/Informatique/Livre/linux-embarque-978221267484"><em>[5] « Linux embarqué, mise en place et développment » (P Ficheux) https://www.eyrolles.com/Informatique/Livre/linux-embarque-978221267484</em></a><em><br></em><a href="https://www.yoctoproject.org/learn/books"><em>[6] Quelques ouvrages dédiés à Yocto https://www.yoctoproject.org/learn/books</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38d979843cb7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/smileinnovation/introduction-%C3%A0-yocto-partie-2-38d979843cb7">Introduction à Yocto (partie 2)</a> was originally published in <a href="https://medium.com/smileinnovation">Smile Innovation</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction à Yocto (partie 1)]]></title>
            <link>https://medium.com/smileinnovation/introduction-%C3%A0-yocto-db56a550ae51?source=rss-968911f3bc20------2</link>
            <guid isPermaLink="false">https://medium.com/p/db56a550ae51</guid>
            <category><![CDATA[connected-devices]]></category>
            <category><![CDATA[iot]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[embedded-systems]]></category>
            <dc:creator><![CDATA[Pierre FICHEUX]]></dc:creator>
            <pubDate>Mon, 19 Mar 2018 07:43:46 GMT</pubDate>
            <atom:updated>2018-04-20T09:49:06.980Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3oFSYv3ykuGC1Gzi." /></figure><p><em>Yocto est devenu un standard de l’industrie pour la technologie « Linux embarqué ». Dans cette courte série de deux articles nous<br>décrirons tout d’abord les principes de cet outil, puis nous décrirons quelques exemples plus avancés dans un deuxième article.</em></p><h4><strong>De la distribution au « build system »</strong></h4><p>La plupart des utilisateurs et développeurs GNU/Linux utilisent des « distributions » (Debian, Ubuntu, Fedora, Red Hat, etc.). Une distribution est constituée d’un ensemble de composants rassemblés dans des « paquets » (packages). Ces paquets sont installés grâce à une procédure (graphique) la plus simple possible, l’utilisateur final n’étant pas forcément un développeur. Dans de nombreux cas on installe la distribution sur un PC/x86 afin de créer un poste de travail qui peut aller de la simple bureautique (Internet, LibreOffice) au développement C/C++, Python ou Java en intégrant des outils comme Eclipse. Un autre cas fréquent est l’installation d’un serveur. Grâce à une autre interface graphique on peut ajouter, retirer ou mettre à jour les paquets installés sur la distribution.</p><p>L’espace occupé par une distribution classique est relativement important car il est rare qu’un disque dur récent ait une capacité inférieure à 1 To (voire plus). Suivant les composants installés, la distribution utilisera donc plusieurs Go, voire plusieurs dizaines de Go sur le disque, et sera composée de milliers de paquets (plus de 3000 sur mon poste de travail sous Ubuntu).</p><p>Depuis plusieurs années GNU/Linux est utilisé pour des solutions industrielles, ou plus récemment pour des solutions « embarquées ». La principale différence correspondant à l’empreinte mémoire utilisée ainsi que la puissance du matériel (CPU, RAM, stockage). A titre d’exemple, la quasi-totalité des boîtiers « gateway » et décodeurs TV proposés par les fournisseurs d’accès à Internet (FAI) utilisent GNU/Linux dans une version adaptée. Il en est de même pour les décodeurs satellite. Ces produits étant largement diffusés (plusieurs millions d’exemplaires) il est indispensable de réduire le coût du matériel et donc en premier lieu l’empreinte mémoire du système d’exploitation donc la taille de la mémoire flash hébergeant ce système (ainsi que la RAM). En outre, ces produits doivent être d’une grande fiabilité. Il est donc indispensable de maîtriser la production du système ainsi que la mise à jour. Pour toutes ces raisons, l’utilisation d’une distribution classique n’est pas recommandée et l’on créera l’image du système à partir des sources des composants en utilisant un outil dédié nommé « build system » que l’on peut traduire par « outil de construction ».</p><h4><strong>Les différents outils disponibles</strong></h4><p>Pendant plusieurs années il n’existait pas d’outils standards et ceux d’aujourd’hui ont été initialement créés en tant qu’outils internes pour d’autres projets. L’outil <a href="https://buildroot.org/">Buildroot</a>¹ était au départ utilisé pour le projet uClibc (puis uClibc-ng). Buildroot a toujours à ce jour une approche « statique » ce qui signifie qu’il n’est pas possible d’ajouter/retirer/mettre à jour des composants sur la cible installée. De même, l’intégralité des recettes et des BSP (Board Support Package) disponibles sous Buildroot sont fournis dans le dépôt officiel (soit près de 1800 recettes et 190 cibles matérielles).</p><p>Son principal concurrent, <a href="http://www.openembedded.org/wiki/Main_Page">OpenEmbedded</a>²— à l’origine de Yocto — fut démarré dans le projet OpenZaurus, une version de GNU/Linux pour le PDA Zaurus de Sharp (sorti en 2002). OpenEmbedded permet de créer — si on le désire — une véritable « distribution » sur mesure bénéficiant d’un système de gestion de paquets similaire à celui des distributions classiques. Nous verrons également que son approche est beaucoup plus « dynamique » tant au niveau des recettes que des BSP disponibles.</p><p>Cette liste des outils n’est pas exhaustive car d’autres produits similaires sont encore utilisés, citons <a href="https://openwrt.org/">OpenWrt</a>⁴ initialement développé pour le routeur WRT54G de Linksys et toujours utilisé sur des passerelles grand public, <a href="https://www.pengutronix.de/en/software/ptxdist.html">PTXdist</a>⁵ créé par Pengutronix ou bien l’ancêtre <a href="http://ltib.org/">LTIB</a>⁶ autrefois utilisé pour les BSP fournis par Freescale (à l’époque). Ces trois derniers outils sont très similaires à Buildroot malgré quelques différences comme le système de gestion de paquets disponible sur OpenWrt. Le principe de fonctionnement d’un build system est toujours le même :</p><p>• L’outil fournit des fichiers décrivant la manière de produire un composant binaire à partir de ses sources pour une cible matérielle donnée (on parle de « recette » similaire à une recette de cuisine). Il faut noter que l’outil ne fournit pas les sources des composants et qu’on les obtient à partir des dépôts des différents projets (kernel.org, busybox.net, github.com, etc.).</p><p>• A partir des composants sélectionnés, l’outil produit les images du système (bootloader, noyau Linux, root-filesystem) et souvent une image unique à écrire sur la mémoire flash de la cible (ou bien la Micro-SD).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*E3hJhQ-nRpy-U7m4MabpMQ.png" /></figure><p>Les outils similaires à Buildroot ont en commun la possibilité de définir le contenu de l’image à produire (i.e. les composants à intégrer) en utilisant un outil graphique identique à celui utilisé pour la configuration du noyau Linux.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/1*mOoTMXmm2JIRgQCOhOKgXw.png" /><figcaption><em>Écran de configuration de Buildroot</em></figcaption></figure><p>En revanche OpenEmbedded (et donc Yocto) n’utilisent — presque — pas d’outil graphique et l’on définit le contenu de l’image par des fichiers de configuration. Cette approche est plus complexe pour l’utilisateur occasionnel mais permet de créer des configurations plus avancées dans le cas d’une approche industrielle.</p><h4><strong>Introduction à Yocto / OpenEmbedded</strong></h4><p>Comme nous l’avons dit OpenEmbedded est né suite aux premiers travaux sur OpenZaurus (qui utilisait Buildroot). Les limites de la version Buildroot de l’époque (2003) — et probablement son approche « statique » — conduisirent les trois principaux développeurs (Chris Larson, Michael Lauer, and Holger Schurig ) à définir leur propre outil de construction constitué de deux projets indépendants.</p><ul><li>Un ensemble de recettes (OpenEmbedded-Core)</li><li>Un outil de construction et d’exploitation des recettes (BitBake)</li></ul><p>Le projet était à l’époque assez complexe à utiliser du fait d’un cruel manque de documentation. Son intégration en 2010 au projet Yocto (projet officiel de la fondation Linux) permit de rationaliser l’architecture et de rendre son usage plus accessible. Yocto est un projet « chapeau » intégrant différents projets libres comme OpenEmbedded, BitBake, Poky ainsi que les grands noms de l’industrie tant au niveau du matériel que du logiciel (Intel, TI, Xilinx , AMD, Mentor Graphics, Wind River, etc.). De ce fait, Yocto est aujourd’hui une référence industrielle et il est utilisé par les fabricants de matériel pour fournir leur BSP Linux. Il est également à la base des solutions d’éditeurs de logiciels comme celles de Wind River (<a href="https://www.windriver.com/products/linux/">Wind River Linux</a>⁷ ). D’autres projets majeurs dans l’informatique embarquée dédiée à l’automobile (IVI pour In Vehicle Infotainment) comme <a href="https://www.yoctoproject.org/product/genivi-baseline">GENIVI</a>⁸ ou <a href="https://www.automotivelinux.org/">AGL</a>⁹ sont également basés sur Yocto.</p><p>L’approche de Yocto est très différente de celle de Buildroot. En effet, Yocto est basé sur une architecture en couches (layers) permettant de construire l’image d’une distribution de référence nommée Poky et d’enrichir cette image en y ajoutant d’autres couches (donc de nouvelles recettes). Seules les couches indispensables (soit oe-core et meta-yocto) sont fournies par le projet Yocto. On peut ensuite ajouter des couches externes liées au matériel (BSP), à des systèmes graphiques comme Qt ou à des composants métier. Comme nous pouvons le constater dans la liste des <a href="http://layers.openembedded.org/layerindex/branch/master/layers">layers répertoriés</a>¹⁰ , un layer est le plus souvent nommé meta-&lt;nom-du-layer&gt; et correspond concrètement à une arborescence de sous-répertoires contenant des recettes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*YOgkFCLDfklNUZi0oP7aWg.png" /><figcaption><em>Les couches (layers) de Yocto</em></figcaption></figure><p>Poky est la distribution de référence mais d’autres sont disponibles comme ELDK de DENX (meta-eldk), Arago de TI (meta-arago-distro), Angstrom (meta-angstrom). Rappelons que des produits commerciaux comme Wind River Linux ou MontaVista Carrier Grade utilisent Yocto comme système de construction.</p><p>Yocto produit systématiquement des paquets binaires au format RPM, IPK ou DEB. Basé sur le format DEB, le format IPK (Itsy Package Format) a l’avantage d’être très compact, bien plus que les deux autres formats (RPM et DEB) compatibles avec les distributions classiques. Le format IPK est également utilisé pour OpenWrt déjà cité en début d’article.</p><p>La base de données des paquets est le plus souvent installée sur la cible ce qui permet l’ajout/suppression/mise à jour comme sur une distribution classique. Cette fonctionnalité n’est cependant pas activée par défaut sur l’image la plus légère que nous testerons au paragraphe suivant.</p><h4><strong>Un premier test de Yocto</strong></h4><p>Un des principes fondamentaux de Yocto est de maintenir une liste de cibles de référence constituée en majorité de cibles émulées par l’outil QEMU (plus quelques cibles génériques, soit 13 au total). Les noms des cibles sont <em>qemux86, qemuarm, qemumips, </em>etc. Si l’on désire construire l’image pour une cible réelle, il faudra obtenir le BSP sous forme de layer dans la liste citée en [10]. Le layer peut également être disponible auprès du fournisseur sans être référencé ni public (mais dans ce cas-là, la méfiance est de mise !).</p><p><strong><em>REMARQUE</em></strong><em> : nous avons dit que le développement des layers externes (comme les BSP) n’est pas de la responsabilité du projet Yocto. Il est donc de la responsabilité des mainteneurs du BSP de suivre les évolutions de Yocto. Ce point est à prendre en compte lors du choix d’une cible matérielle car dans le cas contraire l’utilisateur sera limité à des anciennes versions de Yocto et donc limité dans l’utilisation d’autres layers.</em></p><p>Dans la suite de l’article nous utiliserons le BSP Yocto pour la célèbre carte Raspberry Pi, soit <a href="http://git.yoctoproject.org/cgit/cgit.cgi/meta-raspberrypi">meta-raspberrypi</a>¹¹ . Paradoxalement, le support Yocto de cette carte « grand public » est de très bonne qualité, bien meilleur que celui de certaines cartes industrielles. Avant cela nous allons construire une image pour la cible par défaut soit qemux86.</p><h4><strong>Test pour QEMU/x86</strong></h4><p>La première étape consiste à récupérer les sources du projet Yocto. La branche correspond à la version choisie, chaque version ayant un nom de code (rocko pour 2.4, pyro pour 2.3, morty pour 2.2, etc.).</p><pre>$ git clone -b &lt;branche&gt; git://git.yoctoproject.org/poky</pre><p>On doit alors créer un répertoire de compilation en utilisant le script <strong>oe-init-build-env</strong>. Cette commande a pour effet de créer le répertoire choisi (soit <strong>qemux86-build</strong>) contenant les fichiers <strong>local.conf</strong> et <strong>bblayers.conf</strong> dans le sous-répertoire <strong>conf</strong>.</p><pre>$ cd poky<br>$ source oe-init-build-env qemux86-build</pre><p>La construction de l’image la plus simple nommée « core-image-minimal » correspond à la ligne suivante :</p><pre>$ bitbake core-image-minimal</pre><p>La création de cette image — bien que légère — est relativement longue. En effet, outre la création de l’image à installer sur la cible, la première compilation produit également les outils de compilation croisés. Sur une machine raisonnablement puissante (i7, 8 Go de RAM), le temps de compilation avoisine une heure même si l’utilisation d’un disque SSD améliore considérablement les performances. Une fois l’image produite, on peut la tester en utilisant la commande suivante :</p><pre>$ runqemu qemux86</pre><p>Cette dernière commande doit conduire à l’affichage de la fenêtre de l’émulateur indiquant le démarrage du système.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*UwrLlrU-gAohRM4v4tODRw.png" /><figcaption>Test de l’image Poky pour QEMU/x86</figcaption></figure><h4><strong>Test pour Raspberry Pi 3</strong></h4><p>Si l’on désire tester la même image sur une Raspberry Pi 3, il faut obtenir le layer correspondant et indiquer le type de cible en renseignant la variable d’environnement <strong>MACHINE</strong> dans le fichier <strong>local.conf</strong>. Il est important d’indiquer la même branche que pour les sources de Yocto lors du test précédent.</p><pre>$ cd poky<br>$ git clone -b &lt;branche&gt; git://git.yoctoproject.org/meta-raspberrypi</pre><p>On crée un nouveau répertoire de travail et l’on ajoute le nouveau layer au fichier <strong>bblayers.conf</strong> en utilisant la commande <strong>bitbake-layers</strong> (différente de <strong>bitbake</strong> !). On note que l’on peut utiliser plusieurs répertoires de compilation dans la même arborescence Yocto, ce qui n’est pas possible avec Buildroot.</p><pre>$ source oe-init-build-env rpi3-build<br>$ bitbake-layers add-layer ../meta-raspberrypi</pre><p>On définit ensuite le type de cible.</p><pre>echo “MACHINE = \”raspberrypi3\”” &gt;&gt; conf/local.conf</pre><p>On peut alors créer l’image.</p><pre>$ bitbake core-image-minimal</pre><p>Pour tester sur la Raspberry Pi 3, on copie l’image produite sur une Micro-SD.</p><blockquote>$ umount /dev/mmcblk0p*<br>$ sudo dd if=tmp/deploy/image/raspberrypi3/core-image-minimal-raspberrypi3.rpi-sdimg of=/dev/mmcblk0</blockquote><p>Lors du test sur la carte on obtient finalement les traces suivantes :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*SaEwv9F3F1AWmsFMb4cTNg.png" /></figure><p>On note la très faible empreinte mémoire du système (5,5 Mo) mais il est vrai que nous n’avons pas installé les systèmes de gestion de paquets (package management) sur l’image ni les modules du noyau. L’ajout du système de gestion de paquets IPK permet cependant de conserver une empreinte mémoire très raisonnable (8,5 Mo).</p><pre>root@raspberrypi3:~# df -h</pre><pre>Filesystem  Size   Used Available Use% Mounted on <br>/dev/root   14.5M  8.5M 5.2M      62%  /</pre><h4><strong>Répertoires produits</strong></h4><p>Le test précédent nous a permis de produire une image à tester. Dans cette partie nous allons voir les éléments créés par Yocto (en fait par BitBake). Ces éléments sont tous situés dans des sous-répertoires du répertoire de construction, soit <strong>rpi3-build</strong> dans notre cas. Étrangement, les fichiers directement utilisables sur la cible (en particulier l’image à installer) sont localisés dans un sous-répertoire de <strong>tmp</strong> et dans cet article d’introduction, nous évoquerons uniquement <strong>tmp/deploy</strong> et <strong>tmp/work</strong>. Le plus important est certainement <strong>tmp/deploy/images/raspberrypi3</strong> puisqu’il contient tous les éléments nécessaires au démarrage de la cible (noyau Linux, modules, fichiers « device tree », images du root-filesystem, etc.). Certains BSP, comme celui de la Raspberry Pi, produisent également une image directement utilisable sur une mémoire flash (cas de notre test).</p><p>Si l’on détaille un peu plus <strong>tmp/deploy</strong> on constate qu’il contient trois sous-répertoires.</p><pre>tmp/deploy/ <br>I__images <br>I__ipk<br>I__licences</pre><p>Le sous-répertoire <strong>licences</strong> contient les licences des composants produits lors de la création de l’image. Ce point est important lors d’une démarche industrielle car il est souvent nécessaire de disposer de cette liste. Si l’on détaille le sous-répertoire <strong>ipk</strong>, on constate qu’il contient lui-même trois sous-répertoires.</p><pre>tmp/deploy/ipk/<br>I__all<br>I__cortexa7hf-neon-vfpv4 <br>I__raspberrypi3</pre><p>Le but des sous-répertoires est de classer les paquets binaires produits par catégories. Le sous-répertoire <strong>all</strong> correspond à des paquets indépendants de l’architecture de la cible (scripts, fichiers de données). Le sous-répertoire <strong>cortexa7hf-neon-vfpv4</strong> correspond à l’architecture matérielle de la cible (ici un cœur Cortex A7). Une cible utilisant la même architecture devrait pouvoir utiliser ces paquets. Le sous-répertoire <strong>raspberrypi3</strong> correspond à des paquets spécifiques à la cible comme les pilotes ou les fichiers « device tree » de la Raspberry Pi 3. Notons que si le format de paquets choisi est RPM (valeur par défaut) ou DEB, nous verrons apparaître les sous-répertoires <strong>rpm</strong> et/ou <strong>deb</strong>.</p><p>Le répertoire <strong>tmp/work</strong> nous est moins utile dans un premier temps car il correspond à un répertoire de travail hébergeant la production de chaque paquet binaire à partir des recettes. Outre cela il peut contenir des informations intéressantes comme le contenu du root-filesystem ou les traces d’exécution des recettes (ainsi que les erreurs!). Il est donc destiné à un utilisateur avancé développant ses propres recettes comme nous le verrons dans le deuxième article.</p><h4><strong>Configuration avancée</strong></h4><p>Pour l’instant nous avons uniquement spécifié le type de cible par la variable <strong>MACHINE</strong> dans <strong>local.conf</strong> ainsi que l’ajout du layer meta-raspberry grâce à la commande <strong>bitbake-layers</strong> qui impacte le fichier <strong>bblayers.conf</strong>. Nous allons terminer ce premier article en indiquant quelques options de configurations que l’on peut mentionner dans <strong>local.conf</strong>. Une description complète des options est bien entendu disponible dans la documentation Yocto, en particulier le <a href="http://www.yoctoproject.org/docs/2.4.1/ref-manual/ref-manual.html">manuel de référence</a>¹² . Lors du deuxième article nous décrirons plus précisément la notion de « feature » évoquée ci-après.</p><h4><strong>Réduction de l’espace utilisé</strong></h4><p>La production d’une image correspond à l’exécution par BitBake de plusieurs milliers de recettes. Par défaut chaque étape de construction est tracée dans <strong>tmp/work</strong> et les fichiers intermédiaires correspondant à la compilation des composants sont conservés, ce qui peut occuper plusieurs dizaines de Go sur la machine de développement. Pour réduire la taille de <strong>tmp/work</strong> au strict minimum (soit tout de même 1 Go) on peut ajouter la directive :</p><pre>INHERIT += “rm_work”</pre><h4><strong>Ajout du gestionnaire de paquets</strong></h4><p>Si l’on désire disposer d’un gestionnaire de paquets binaire sur la cible, on peut ajouter la ligne suivante :</p><pre>EXTRA_IMAGE_FEATURES += “package-management”</pre><p>On peut également spécifier le format de paquet utilisé qui par défaut est <strong>package_rpm</strong>.</p><pre>PACKAGE_CLASSES = “package_ipk”</pre><h4><strong>Ajout d’espace libre sur la cible</strong></h4><p>La taille du root-filesystem est calculée par Yocto au plus juste et nous avons vu lors de notre test qu’il restait à peine 5 Mo d’espace disponible. Si l’on veut augmenter l’espace libre on peut indiquer le volume à ajouter (en Ko).</p><pre>IMAGE_ROOTFS_EXTRA_SPACE = “50000”</pre><h4><strong>Ajout d’un format de root-filesystem</strong></h4><p>En fonction du BSP, Yocto construit les images du root-filesystem dans <strong>tmp/deploy/images/&lt;nom-de-cible&gt;</strong>. Si l’on désire ajouter un format d’image supplémentaire, on peut utiliser la variable <strong>IMAGE_FSTYPES</strong>. Dans l’exemple qui suit on produit en plus une image au format Initramfs (soit une archive CPIO compressée).</p><pre>IMAGE_FSTYPES += “cpio.gz”</pre><h4><strong>Construction d’une image en lecture seule</strong></h4><p>Dans de nombreux cas de figures, il est judicieux que le root-filesystem installé sur la cible en production soit en lecture seule. Pour cela il suffit d’ajouter la ligne suivante :</p><pre>EXTRA_IMAGE_FEATURES += “read-only-rootfs”</pre><h3><strong>Conclusion</strong></h3><p>Dans cette première partie nous avons pu voir les rudiments de l’utilisation de Yocto après une brève comparaison avec d’autres outils comme Buildroot. Dans un prochain article nous verrons comment construire nous-même des recettes afin d’enrichir notre image.</p><h4><strong>Bibliographie</strong></h4><p><em>[1] Buildroot sur </em><a href="https://buildroot.org/">https://buildroot.org</a><br> <em>[2] OpenEmbedded sur </em><a href="http://www.openembedded.org/wiki/Main_Page">http://www.openembedded.org/wiki/Main_Page</a><br> <em>[3] Projet Yocto sur </em><a href="https://www.yoctoproject.org/">https://www.yoctoproject.org/</a><br> <em>[4] OpenWrt sur </em><a href="https://openwrt.org/">https://openwrt.org/</a><br> <em>[5] PTXdist sur </em><a href="https://www.pengutronix.de/en/software/ptxdist.html">https://www.pengutronix.de/en/software/ptxdist.html</a><br> <em>[6] LTIB sur </em><a href="http://ltib.org/">http://ltib.org/</a><br> <em>[7] Wind River Linux sur </em><a href="https://www.windriver.com/products/linux/">https://www.windriver.com/products/linux/</a><br> <em>[8] Projet GENIVI sur </em><a href="https://www.yoctoproject.org/product/genivi-baseline">https://www.yoctoproject.org/product/genivi-baseline</a><br> <em>[9] Automotive Grade Linux sur </em><a href="https://www.automotivelinux.org/">https://www.automotivelinux.org</a><br> <em>[10] Liste des layers officiels sur </em><a href="http://layers.openembedded.org/layerindex/branch/master/layers">http://layers.openembedded.org/layerindex/branch/master/layers</a> <br> <em>[11] Layer du BSP Raspberry Pi sur </em><a href="http://git.yoctoproject.org/cgit/cgit.cgi/meta-raspberrypi">http://git.yoctoproject.org/cgit/cgit.cgi/meta-raspberrypi</a><br> <em>[12] Manuel de référence Yocto sur </em><a href="http://www.yoctoproject.org/docs/2.4.1/ref-manual/ref-manual.html">http://www.yoctoproject.org/docs/2.4.1/ref-manual/ref-manual.html</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db56a550ae51" width="1" height="1" alt=""><hr><p><a href="https://medium.com/smileinnovation/introduction-%C3%A0-yocto-db56a550ae51">Introduction à Yocto (partie 1)</a> was originally published in <a href="https://medium.com/smileinnovation">Smile Innovation</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>