Systèmes Embarqués Libres

Systèmes Embarqués Libres Djalal Harouni tixxdz@opendz.org Pr. Mohamed Benmohammed Laboratoire Informatique LIRE, Université Mentouri Constantine Sofware Freedom Day 2011 Algeria. 1

Systèmes Embarqués Libres Durant cette présentation on va voir les principes des systèmes embarqués et comment les logiciels et les outils libres et Open Source peuvent être utilisés pour construire et réaliser ces systèmes. Les aspects les plus techniques seront détaillés durant l'atelier 'Systèmes Embarqués Libres'. 2

Plan Introduction Systèmes Embarqués Outils Libres Création du système embarqué Test et exécution Conclusion 3

Introduction Le concept d un système embarqué: C est un système numérique dédié à une ou quelques tâches bien précises [1]. Les interfaces I/O tel que le clavier et l écran peuvent être absentes, de ce fait on peut dire que c est un système autonome. Ce n est pas un PC (ou presque un PC). Les caractéristiques: Ils utilisent des microprocesseurs ou microcontrôleurs à basse consommation d énergie. Certain systèmes embarqués doivent répondre a des contraintes de temps réels [1], de ce fait on peut les appeler systèmes temps réels. Le logiciel des systèmes embarqués peut être appelé firmware. Ce firmware est généralement stocké dans une mémoire morte (ROM, PROM, EPROM etc.) 4

Introduction L intérêt: Consommation énergétique faible. Réduction des coûts par l utilisation seulement du matériel nécessaire. Peut répondre mieux au contraintes temporels d une tâche, car le système doit se focaliser que sur cette tâche. Exemple de systèmes embarqués: Console de jeux, télévision, four a micro-ondes, robots Disque dur, imprimante, photocopieur, téléphonie, routeur, pare-feu. Fusée, missile, sonde spatiale, matériel médical, GPS Processeur pour systèmes embarqués: ARM (Advanced RISC Machine): une architecture destinée aux systèmes embarqués tel que: iphone, série Nokia, console de jeux etc. MIPS (Microprocessor without Interlocked Pipeline Stages): une architecture RISC utilisée dans les modems, télévisions, consoles de jeux etc. (Il y a une dizaine de processeurs destinés aux systèmes embarqués). 5

Systèmes Embarqués Exemples de systèmes embarqués: Sharp Zaurus SL-5500 PDA Linux [2] TomTom GPS [3] 7

Systèmes Embarqués Quelques systèmes embarqués basés sur un kernel Linux [4]: Android Un système embarqué pour les téléphones, développé maintenant par Google [5]. UcLinux Linux pour les microcontrôleurs ne disposant pas de MMU [6]. Utilisé pour les petits systèmes embarqués. Openmoko : un système embarqué pour les téléphones [7]. OpenWrt : un système GNU/Linux pour les routeurs [8]. 8

Systèmes Embarqués Architecture d'android [9]. 9

Outils libres - Linux Linux est un système libre développé sous licence GPL [4] [10]. Intérêt pour le monde embarqué: Code stable et de bonne qualité. Contrôle total sur le système, aucune contrainte, la possibilité de modifier n'importe quelle partie du système. Support de plusieurs architecture et protocoles réseaux. tix@x64_k:linux $ ls arch/ arm blackfin frv hexagon m32r microblaze mn10300 parisc s390 sh tile unicore32 alpha avr32 cris h8300 ia64 m68k mips openrisc powerpc score sparc um x86 xtensa tix@x64_k:linux $ make kernelversion 3.2.0-rc2 11

Outils libres Outils de compilation et de génération de code: Cross-compilation toolchain: c'est la suite utilisée pour la génération du code sur une machine X pour qu'il soit exécuté sur une autre machine d'une architecture Y. On utilise le compilateur GCC [11] qui supporte plusieurs langages et plusieurs architectures. Pour produire du code pour une autre architecture on utilise l'option '--target' On a besoin aussi de la suite binutils [12] qui regroupe le GNU assembleur, on aura besoin aussi de la suite Autools pour configurer les programmes et générer les Makefiles. C library: l'interface entre le kernel et les applications. Glibc: GNU C Library [13]. uclibc: C library pour les systèmes embarqués [14]. dietlibc: C library pour les systèmes embarqués [15]. 12

Outils libres Bootloaders: X-loader [16]: Un petit bootloader (first stage) qui va initialiser la mémoire et les périphiriques et charger U-boot (second stage). Chaque architecture peut avoir son propre chargeur. U-boot (Universal Boot Loader) [17]: Un bootloader (second stage) qui va initialiser le hardware et charger le kernel. Il est sous licence GPL. Il supporte plusieurs architectures: PPC, ARM, MIPS, X86,... Il permet de charger le kernel à partir d un disque, mémoire flash, réseau en utilisant le protocole TFTP. 13

Outils libres BusyBox [18]: Un outil open source qui regroupe plusieurs outils standards des systèmes de type Unix. C'est un seul programme compilé statiquement, destiné aux systèmes embarqués, pour gagner en mémoire et espace disque. Il est utilisé sur plusieurs routeurs, téléphones IP, NAS (Network attached Storage) etc. Pour exécuter une commande: tix@x64_k:linux$ /bin/busybox ls Quelques outils inclus: awk cat chmod copy dd dmesg echo grep egrep fgrep gzip kill ls mkdir mount umount pidof ping mv rm vi ash... 14

Outils libres Buildroot [19]: Buildroot est un ensemble de Makefiles et de patches. Il permet l'automatisation du processus de génération des outils de cross-compilation. Il permet de créer des systèmes embarqués utilisant un kernel Linux plus facilement: image kernel, bootloader... etc. Il supporte plusieurs architectures: PPC, ARM, MIPS, X86 15

Outils libres Qemu outil d'émulation et de virtualisation [20][21]: C'est un émulateur et aussi un logiciel de virtualisation Open Source. Il permet d'émuler plusieurs architectures et processeurs tel que les architectures utilisées dans les systèmes embarqués: x86, PowerPC, ARM, Sparc, MIPS... On peut l'utiliser sur un PC x86 pour le développement d'applications et le test de systèmes embarqués destinés à une autre architecture tel que les processeurs ARM. En simulant un processeur ARM, Qemu vas utiliser un mécanisme de traduction de code ASM. 16

Outils libres Résumé GNU/Linux pour PC et pour l'embarqué: PC: Grub (bootloader) Kernel qui inclut plusieurs options (driver et protocols). GNU C Library. Shared libraries. Embarqué: U-boot (X-loader?) Kernel léger (le necessaire). Uclibc: library C optimisé pour les systèmes embarqués. Shared libraries. Outils de commande: shell, ssh, ls, sudo, su, wget, gcc... Serveur Xorg, Browser, multimedia... etc Busybox: outil qui regroupe plusieurs programmes. Interface graphique? 17

Création du système embarqué La création d'un système embarqué passe par plusieurs étapes [22] : 1. Identification du matériel, de l'architecture utilisée et des différents composants du système. 2. Préparation de l'environnement. 3. Cross compilation toolchain. 4. Configuration et compilation du kernel Linux. 5. Construction du système de fichiers et installation du kernel. 6. Configuration et installation du bootloader. 19

Création du système embarqué 1) Identification du matériel et de l'architecture du circuit intégré. Exemple d'une carte mère Beagle Board [23] utilisée beaucoup plus pour le développement embarqué: TI OMAP3530 multicore processor: incluant un processeur ARM Cortex-A8 core basé sur l'architecture ARMv7. 256MB RAM and Nand flash memory. MicroSD connector. Ethernet 10/100 Mb port.... 20

Création du système embarqué 1) Identification du matériel et de l'architecture du circuit intégré. Beagle Board [24] (pour le développement): Beagle Board (Taille 78,7 x 76,2 mm Alimentation 5V) 21

Création du système embarqué 3) Cross toolchain: GNU Toolchain: GNU Make, GNU Compiler Collection (GCC), GNU Binutils (assembler and linker), GNU Debugger (GDB), GNU C Library... GMP library: les opérations arithmétiques (integer, float numbers) [25]. MPFR library: calculer les nombres à virgule flottante en précision arbitraire [26]. MPC library: pour calculer les nombres complexes à virgule flottante [27]. Linux kernel headers [4]. GNU Toolchain utilise généralement trois définitions: Build plateform: la machine où on va compiler le code. Host plateform: la machine où on va exécuter le code compilé. Target plateform: le type du code produit. Ces définition vont prendre la valeur d'un Target Triplet: cpu-vendor-os. 22

Création du système embarqué 3) Cross toolchain: L'architecture du CPU sera: arm. CPU endianness (ordre des octets): little-endian. L'architecture ou la spécification ARM sera: ARMv4... ARMv7 ABI (Application Binary Interface) pour les architectures ARM: La valeur de l'abi sera EABI (Embedded ABI) pour les ARMv4t et plus. Le Target Triplet (cpu-vendor-os) pour notre cible: armv7a-none-linux-gnueabi ou armv7a-none-linux-uclibceabi 23

Création du système embarqué 3) Cross toolchain: Exemple d'architectures de processeur ARM: armv4, armv4t, armv5,.., armv7, armv7-a, armv7-m... Exemple d'architectures processeur ARM, d'abi et de Target Triplet [28]: Processor Endianess ABI Target Triplet Generic ARM Little OABI arm-unknown-linux-uclibc Generic ARM v5 Little EABI armv5l-unknown-linux-uclibceabi Generic ARM v5 Big EABI armv5b-unknown-linux-uclibceabi Generic ARM v7a Little EABI armv7a-unknown-linux-uclibceabi Generic ARM Little EABI arm-unknown-linux-uclibceabi Generic ARM Little EABI arm-unknown-linux-gnueabi 24

Création du système embarqué Cross toolchain: voici les étapes pour générer le cross compiler. Il faut utiliser les mêmes options lors de la configuration: '--with-sysroot', '--prefix'... Configurer et compiler la suite GNU Binutils pour avoir un assembleur et un lieur pour le code ARM produit. binutils $./configure target=arm-linux && make ensuite il faut l installer. Pour compiler GCC on a besoin d'installer les fichiers: Linux Kernel headers. kernel $ make mrproper && make ARCH=arm headers_check... 25

Création du système embarqué 3) Cross toolchain: Configurer, compiler et installer les bibliothèques: GMP, MPFR et MPC. Configurer et compiler GCC de façon statique et minimale avec le support du langage C seulement et sans le support des threads. Cette opération va permettre de compiler une bibliothèque C (GNU libc ou uclibc...), qui va ensuite être utilisée pour compiler le Cross Compiler final. gcc-src $./configure --target=arm-none-linux disable-threads --enable-languages=c... && make && make install Configurer et compiler la bibliothèque C: uclibc ou GNU Libc... Configurer et recompiler GCC le Cross Compiler final avec support des threads... en utilisant la bibliothèque C compilée. 26

Création du système embarqué 3) Cross toolchain: Crosstool-NG [29]: Un ensemble d'outils et de scripts qui permettent d'automatiser la procédure de génération de la cross toolchain. Il supporte différentes architectures. Utilise un menu de configuration comme celui du kernel Linux. Supporte uclibc, glibc, eglibc... 27

Création du système embarqué 4) Configuration et compilation du kernel: Utiliser linux-omap git branch [30]. Utiliser un kernel modifié ou un kernel par défaut avec un fichier de configuration: linux/arch/arm/configs/omap2plus_defconfig linux $ make ARCH=arm omap2plus_defconfig linux $ make ARCH=arm help (pour voir les configurations par défaut) Configurer le kernel selon l'architecture et le matériel disponible: linux $ make mrproper (supprime.config sinon: 'make clean') linux $ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi menuconfig Compiler et produire l'image du kernel avec les modules: linux $ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi uimage modules linux $ make INSTALL_MOD_PATH=${SYSROOT} modules_install 28

Création du système embarqué 4) Configuration et compilation du kernel: 29

Création du système embarqué 5) Le système de fichiers: Utiliser un système de fichier adapté aux systèmes embarqués tel que: SquashFS: système de fichier compressé en lecture seul. JFFS2 (Journalling Flash File System). On peut aussi utiliser d'autres types: ext2, ext3 etc. Généralement deux partitions ou plus: La première partition va contenir les deux stages du bootloader et l'image du kernel. Les partitions suivantes vont contenir le système de fichiers. 30

Création du système embarqué 6) Configuration bootloader U-boot: Le fichier boot.cmd contient les paramètres de boot. boot.cmd: setenv bootcmd 'mmc init; fatload mmc 0:1 0x80300000 uimage; fatload mmc 0:1 0x81600000 uinitrd; bootm 0x80300000 0x81600000' setenv bootargs console=tty0 console=ttyo2,115200n8 root=/dev/mmcblk0p2 rootwait ro Boot Compiler le fichier boot.cmd en boot.scr avec l'outil mkimage. $ mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n 'boot script' -d boot.cmd boot.scr Copier boot.scr, U-boot, X-loader (ou MLO), uimage et uinitrd dans la partition boot et booter. 31

Création du système embarqué Buildroot peut automatiser la génération de la chaîne de cross compilation et du système embarqué [19]. Utilise un menuconfig comme celui du kernel. Supporte plusieurs architectures. Permet de générer plusieurs composants tel que le système de fichiers et le kernel. 32

Test et exécution Test d'un kernel configuré et compilé pour un processeur ARM: 1) Avec un émulateur libre tel que Qemu Pour l'émulation d'architecture et machine on utilise: qemu-system-arch Pour l'architecture ARM 'qemu-system-arm' linux$ qemu-system-arm -kernel zimage -initrd arm.img Taille du kernel 3MB. 2) Sur une carte mère de type Beagle board avec: un OMAP3530 (ARM Cortex-A8 CPU + TMS320C64x+ DSP ) + SD/MMC + USB + jtag + RS-232 + NAND flash + 265 RAM + Ethernet etc. Taille 78,7 x 76,2 mm Alimentation 5V pour 500 ma. 34

Test et exécution Figure: kernel ARM running under Qemu 35

Conclusion Dans cet présentation nous avons vu les principes des systèmes embarqués. Les Outils libres et Open Sources disponibles qui peuvent être utilisés pour le développement des systèmes embarqués avec une maîtrise totale. La cross compilation des utilitaires nécessaires pour le développement sur d'autres architectures. La compilation de notre propre kernel Linux, qui sera destiné à un matériel informatique bien précis. Les outils libres et Open Source peuvent aider à l'étude des systèmes embarqués d'une façon plus efficace, car le développeur à le contrôle et peut faire des tests et des implémentations au niveau kernel pas seulement au niveau applicatif. 37

Conclusion Documentation: Building Embedded Linux Systems by Karim Yaghmour, Jon Masters, Gilad Ben-Yossef, Philippe Gerum. Embedded Linux Primer: A Practical Real-World Approach (2nd Edition) by Christopher Hallinan. Embedded Linux wiki : http://elinux.org/main_page Open Embedded (Framework pour la construction des systèmes embarqués): http://www.openembedded.org/wiki/main_page Free Electrons : http://free-electrons.com/docs/ 38

Références [1] http://en.wikipedia.org/wiki/embedded_system [2] http://www.linuxfordevices.com/c/a/linux-for-devices-articles/device-profile-sharps- Zaurus-SL5500-Linux-PDA/ [3] http://tomtom.com/ [4] http://www.kernel.org/ [5] http://www.android.com/ [6] http://uclinux.org/ [7] http://www.openmoko.com/ [8] http://openwrt.org/ [9] http://developer.android.com/guide/basics/what-is-android.html [10] http://www.gnu.org/licenses/old-licenses/gpl-2.0.html [11] http://gcc.gnu.org/ [12] http://www.gnu.org/software/binutils/ [13] http://www.gnu.org/software/libc/ [14] http://www.uclibc.org/ [15] http://www.fefe.de/dietlibc/ 39

Références [16] http://gitorious.org/x-load-omap3 [17] http://www.denx.de/wiki/u-boot [18] http://www.busybox.org/ [19] http://buildroot.uclibc.org/ [20] http://qemu.org/ [21] http://fr.wikipedia.org/wiki/virtualisation [22] Building Embedded Linux Systems by Karim Yaghmour, P27. [23] http://beagleboard.org/ [24] http://en.wikipedia.org/wiki/beagleboard [25] http://gmplib.org/ [26] http://www.mpfr.org/ [27] http://www.multiprecision.org/ [28] http://cross-lfs.org/view/clfs-embedded/arm/cross-tools/variables.html [29] http://crosstool-ng.org/ [30] http://git.kernel.org/?p=linux/kernel/git/tmlind/linux-omap.git 40