Vous êtes sur la page 1sur 8

MALARD Elise PIERRE-NICOLAS Fabien E3 SE

TP de mise en œuvre de Linux embarqué : µCLinux

L’évolution des techniques permet de réaliser des systèmes embarqués capables d’effectuer de plus en plus de tâche. Dans ces conditions il devient nécessaire de faire appel à un système d’exploitation pour les ordonnancer. De plus, la complexité et le nombre de ces tâches allant en grandissant, il est beaucoup plus simple, voir indispensable, de faire appel à un système d’exploitation déjà existant ; cela permet de réduire grandement les temps de conception et d’avoir dès le début une base de travail solide. Le système µCLinux est un système d’exploitation développé spécialement pour les systèmes embarqués. Il présente donc toutes les caractéristiques de ces derniers à savoir une faible empreinte mémoire et des besoins en ressources réduits. De plus, il a l’avantage d’être libre. Nous allons dans ces TP voir quelques utilisations de ce système à travers quelques applications pratiques.

TP 0 : Prise en main

Pour la mise en place de µCLinux nous avons besoin de deux systèmes. Le premier est le système qui nous sert de poste de travail. Il s’agit d’un PC sous distribution Linux (Fedora) classique qui sert d’hôte. Le second est la carte d’évaluation sur laquelle nous allons implanter µCLinux. Elle est munie d’un processeur ColdFire EVB5407C3.

Il y a deux connectivités permettant la communication entre ces deux architectures :

Une liaison série standard. Une liaison Ethernet. Les deux postes sont reliés à un routeur. L’adresse IP du PC est 192.196.4.6, celle de la carte 192.196.4.106 et celle du routeur 192.196.4.0.

L’application minicom permet de communiquer directement avec la carte en effectuant une lecture/écriture sur le port série ou par la communication Ethernet.

Il est possible grâce à elle de télécharger un fichier binaire par le réseau Ethernet en utilisant la commande :

dn –i image.bin

On peut aussi télécharger par le réseau Ethernet un fichier S-Record avec la commande:

dn –s srec.out -o 20000

Le point d’entrée des exécutables précédemment chargé se trouve en mémoire à l’adresse 20000. Pour les exécuter, il suffit de taper :

go 20000

Le format S-Record de Motorola est un encodage en caractères ASCII d’un fichier binaire exécutable par un processeur compatible.

TP 1 : Prise en main

Nous allons maintenant télécharger et utiliser le système µCLinux sur la carte d’évaluation. Pour cela on utilise la commande :

dn image0.bin

Elle copie le binaire du noyau µCLinux dans la mémoire par l’intermédiaire de la liaison Ethernet. On lance ensuite le programme avec :

go 20000

On a alors accès à une console élémentaire sous µCLinux. La puissance de la cible est de 149,4 BogoMIPS. La taille du noyau (kernel code) est de 416 ko. Nous sommes connectés sous l’utilisateur superuser.

Avec la commande ps on peut observer les différents processus qui tournent :

- Le serveur web boa

- Le daemon inetd

- Le serveur hcp dhcpcd

- sh

- nfsiod

- kflushd

- init

La commande free nous permet de savoir à tout moment la taille de l’espace mémoire libre sur la cible.

Nous allons maintenant configurer le réseau pour pouvoir communiquer depuis la machine cible avec la machine hôte. On commence par définir l’adresse IP, le netmask ainsi que l’adresse de broadcast :

ifconfig eth0 192.168.4.106 netmask 255.255.255.0 broadcast

192.168.4.255

Puis on indique que la connexion doit passer par le routeur

route add –net 192.168.4.0

On vérifie ensuite que la connexion entre la machine cible et la machine hôte est effective en effectuant un ping :

ping 192.168.4.6

Ce test étant réussi, nous allons maintenant tester le serveur WWW embarqué sur la cible. Pour cela on lance un navigateur web sur le PC hôte et on se rend à l’adresse http://192.148.4.106. Ce lien fonctionne et l’on a accès à la page hébergée sur le serveur WWW de la carte. Par contre les scripts CGI ne sont pas disponibles. Le package permettant la mise en place du serveur WWW est le package boa.

TP 2 : Génération d’un noyau µCLinux et tests

Dans ce TP, nous allons générer notre propre noyau µCLinux pour ColdFire. Cette opération permet notamment de choisir la version du noyau Linux que nous voulons et surtout de choisir les packages que l’on désire installer.

Après avoir décompressé et installé le package µCLinux pour ColdFire on configure le noyau en utilisant la commande

make xconfig

On choisit alors notre noyau (noyau 2.4.x) ainsi que la carte cible (Motorola M5407C3). On ajoute aussi le package dungeon du menu Games (jeu d’aventure en mode texte) pour qu’il soit accessible sur notre carte cible. On sauvegarde les dépendances :

make dep

Puis on compile :

make

Le fichier image.bin ainsi généré se trouve dans le répertoire images. On génère le fichier S- Record du noyau à l’aide de la commande :

m68k -elf -objcopy --input -target=binary --output -target=srec images/image.bin images/image.srec

On envoie maintenant, par le port série, le fichier ainsi créer sur la cible en revenant sur minicom et en faisant Ctrl+A, Z puis S et en choisissant le fichier image.srec. Cette opération prend un temps conséquent, démontrant l’intérêt d’une connexion Ethernet, nettement plus rapide.

On vérifie maintenant que le package dungeon est bien installé en le lançant grâce à la commande dungeon. Il nous est alors possible de jouer au jeu On a ainsi pu voir qu’il est très facile de configurer son noyau pour y inclure les applications que l’on veut afin d’obtenir les fonctionnalités désirées et de supprimer les packages inutiles afin de réduire l’empreinte mémoire du noyau.

TP 3 : Mise en œuvre de NFS sous µCLinux

Il pourrait s’avérer intéressant de mettre en œuvre le montage NFS sur notre cible. Le montage NFS permet d’accéder aux dossiers d’une machine distante comme s’ils s’agissaient de répertoires locaux. Pour cela il nous faut de nouveau générer notre noyau en incluant ce dernier. On doit donc de nouveau choisir notre configuration. On choisit maintenant le noyau

2.0.x et l’on sélectionne mount/umount dans uCLinux application Configuration puis

l’on génère le noyau. On télécharge et on exécute le noyau sur la cible.

On configure ensuite le réseau (cf. TP1) puis on effectue le montage NFS en utilisant comme répertoire de montage /mnt :

mount -t nfs 192.168.4.6:/home/uclinux /mnt

Pour trouver le point de montage, on regarde le fichier /etc/exports :

/home/uclinux 192.168.4.106 (rw, root-squash, sync)

dossiers mis à disposition

machine cible

droits passe la cible en simple user

Il nous est désormais possible d’accéder aux fichiers présents dans le dossier /home/uclinux de la machine hôte depuis la machine cible comme s’il s’agissait de fichiers locaux. Cela nous permet de profiter de la capacité de stockage et de la puissance de la machine hôte tout en restant dans notre environnement cible. Il est donc par exemple possible de créer et de compiler un programme depuis notre machine hôte pour notre machine cible (compilation croisée) dans le répertoire /home/uclinux afin que celui-ci soit exécutable directement par la machine cible. La compilation sera plus rapide (puisque la machine hôte est plus puissante) et il n’y aura pas à transférer l’exécutable ou les sources à chaque nouvelle version pour tester.

TP 4 : Création d’une application userland sous µCLinux

Nous allons maintenant créer une application userland sous µCLinux c'est-à-dire une application qui fera partie des applications standards installées avec le noyau et qui feront parties de l’environnement user. Le programme que nous allons utiliser pour cet exemple est le classique « Hello World ! ».

Le fichier source hello.c et le makefile de cette application existent déjà, il nous suffit de les récupérer et de les placer dans le dossier uCLinux-dist/user/hello. Il faut légèrement modifier le fichier hello.c n en ajoutant exit(0) à la fin du main pour le rendre opérationnel.

On ajoute ensuite la directive suivante dans le fichier uClinux-dist/user/Makefile :

dir_$(CONFIG_USER_HELLO_HELLO)

+= hello

Ainsi que cette directive dans le fichier uClinux-dist/config/config.in :

bool ‘hello’ CONFIG_USER_HELLO_HELLO

Puis on configure le noyau. On valide l’ajout de l’application hello (ainsi que le NFS). Lors de la compilation, on peut voir que le fichier hello.c est lui aussi bien compilé. Puis on envoie le noyau sur la cible par le réseau.

Pour tester que l’application fonctionne bien, on peut d’abord taper la commande hello. Le message Hello World ! s’affiche bien.

Il est aussi possible de tester l’application en copiant l’exécutable hello du dossier uCLinux- dist/user/ dans le dossier /home/uclinux. On se place alors dans le dossier /mnt de la cible où l’on a accès à l’exécutable hello (grâce au NFS) puis on l’exécute avec la commande ./hello. On constate ici aussi que cela fonctionne.

Nous avons donc pu voir dans ce TP deux techniques différentes pour exécuter des programmes sur notre cible. La première, en l’incluant dans l’userland, permet d’avoir accès facilement à notre application dès le téléchargement du noyau. Elle est donc très utile dans le cas d’applications finies que l’on souhaite voir implantées sur notre cible par défaut avec le noyau. La deuxième façon, par le NFS, est très utile pour le debuggage. En effet, on peut compiler le fichier depuis le PC hôte et profiter ainsi de sa puissance (cross-compilation) et on évite aussi de transférer les fichiers de l’hôte vers la cible. On gagne donc beaucoup en vitesse.

TP 5 : Développement d’une application serveur embarquée sous µCLinux et d’une application cliente Linux pour le contrôle de la carte cible

Ce TP nous propose d’ajouter l’application myserver à l’userland comme nous venons de le faire dans le TP précédent (récupération des sources, modification des fichiers

uClinux-dist/user/Makefile, uClinux-dist/config/config.in puis configuration et

compilation du noyau).

On charge ensuite notre noyau sur la cible et on configure le réseau (cf. TP 1). Puis on lance notre application sur le numéro de port 2000 :

myserver 2000

Puis depuis le PC hôte, on compile le fichier source du client myclient0.c puis on l’exécute en lui précisant l’adresse de notre carte cible ainsi que le port 2000 :

./a.out uc6 2000

Il est alors possible de piloter les leds de la carte cible en envoyant des requêtes à l’aide du client TCP.

Cette méthode de connectivité IP est très pratique car très simple à mettre en place. Cependant elle n’est pas très sûre car il suffit de connaître l’adresse de la cible ainsi que le port sur lequel est lancé le serveur pour y avoir accès.

TP 6 : Mise en œuvre d’un client SMTP sous Linux

Nous souhaitons ici envoyer un mail depuis la carte cible à l’utilisateur uclinux sur la machine hôte grâce à un client SMTP. Après avoir configurer les paramètres de connexion, on crée la connexion SMTP avec l’outil telnet :

telnet 192.168.4.6 smtp

Puis, pour envoyer un mail depuis la cible vers la machine hôte il nous suffit de taper :

mail from root@localhost to uclinux@kiwi6

Pour récupérer ce mail, il faut, sur le PC hôte, taper mail. On constate alors que l’utilisateur uclinux a bien reçu un nouveau mail provenant de la carte cible.

Cette méthode de connectivité semble plus sûre que la précédente car le destinataire est ciblé par son adresse IP. Cependant, il est toujours possible d’intercepter ce mail en utilisant l’adresse IP de la cible. De plus ces fonctionnalités sont limitées. Par contre, le protocole SMTP étant très utilisé, elle s’avère très pratique pour effectuer un retour d’informations depuis la carte cible

TP 7 : Mise en œuvre d’un client SMTP embarqué sous µCLinux

La prochaine étape consiste à inclure le client SMTP à l’userland en vue d’une application embarquée. Pour cela, on utilise la même procédure que précédemment à savoir

modification des

dist/config/config.in puis configuration du noyau, génération des dépendances, compilation. On télécharge ensuite le noyau sur la cible, on le lance et on tape la commande

smtp pour lancer le client SMTP.

fichiers

uClinux-dist/user/Makefile

et

uClinux-

Ainsi embarquée, le client SMTP est parfait pour effectuer des rapports non confidentiels (pour indiquer l’état de la carte par exemple). En effet, comme nous l’avons vu le protocole SMTP n’est pas sécurisé.

TP 8 : Mise en œuvre d’un serveur web embarqué sous µCLinux

Toujours en vue d’expérimenter plusieurs méthodes de connectivité, nous allons mettre en œuvre un serveur web embarqué qui nous permettra de contrôler l’allumage de leds sur la carte cible à distance. On commence par ajouter le programme cgi_generic à l’userland et l’on valide l’application boa lors de la configuration du noyau. Ce programme contient un script CGI qui permet d’éteindre ou d’allumer une led. Une fois le noyau chargé sur la cible, on configure le réseau et on lance le serveur avec la commande :

boa c /home/httpd

Puis, pour contrôler les leds, depuis le PC hôte, il faut se connecter au serveur web en utilisant un navigateur web, dans notre cas, nous utiliserons Netscape. Puis on se connecte à l’adresse de notre carte sur le port 80 (port utilisé par le serveur web). Le script CGI se trouve dans le

répertoire cgi-bin et se nomme enseirb. On lui passe les arguments en suivant le nom du script d’un ? puis de l’argument (1 ou 0 pour ce script). Ainsi, pour allumer la led, il faut donc taper dans la barre d’adresse du navigateur :

http://192.168.4.106:80/cgi-bin/enseirb?1

Cette méthode de connectivité est très puissante car elle permet de contrôler très facilement la carte cible à distance. Cependant, il est impossible de savoir si la carte réagit correctement à nos demandes. De plus, cette méthode n’est pas forcément très sécurisée. Dans notre exemple, n’importe qui connaissant l’adresse de la cible et le port utilisé peut prendre le contrôle des leds.

TP 9 : Mise en œuvre de SNMP sous Linux

Comme nous l’avons vu précédemment, le serveur web ne permet pas de connaître l’état de la carte mais juste de lui envoyer des instructions. Ce protocole n’est donc pas très fiable. Nous allons maintenant regarder la connectivité IP par SNMP d’un équipement électronique connecté sur le port parallèle et constater qu’elle offre un meilleur contrôle. On commence par lancer l’agent SNMP avec la commande :

snmpd

En utilisant l’outil netstat, on observe que cet agent se trouve sur le port d’écoute 161. Il est possible d’effectuer différents contrôles pour connaître l’état de la carte. La commande suivante nous permet parcourir la MIB :

snmptranslate -Tp

On peut aussi connaître l’état des commande :

8

leds qui

se trouvent sur la carte en tapant cette

snmpset –v 1 –c tst localhost enseirb.leds 0.0

L’agent SNMP permet donc, non seulement de donner des instructions à la carte cible à distance, mais aussi de récupérer des informations sur son état. C’est donc un mode de connectivité particulièrement adapté à l’embarqué.

TP 10 : Mise en œuvre d’un agent SNMP embarqué sous µCLinux

Nous allons donc mettre en œuvre cet agent SNMP sur notre carte cible. On

commence

l’application ucd snmpd dans l’userland. Puis, on étend l’agent SNMP avec la MIB ENSEIRB (qui est similaire à la MIB Linux) en le patchant avec mysnmppatch. Il faut compléter le fichier enseirb.c de contrôle des leds en remplissant les « switch case » des différentes actions pour chaque led. Par exemple pour la led 0 :

validant

par

configurer

le

noyau

pour

qu’il

utilise

le

package

SNMP

en

case ACTION if (* long-ret = = 0) *PADAT &= 0xFF7F;

if (* long-ret = = 1) *PADAT |= 0x0080;

break;

Il faut aussi compléter les fonctions d’envoi des TRAPs :

send_easy_trap(7,led7) ;

Puis, on modifie le fichier uClinux-dist/user/ucdsnmp/mysnmpd.conf pour qu’il

corresponde aux adresses IP de la cible et de l’hôte. Une fois cela fait, on compile et on télécharge le noyau sur la cible. Il est alors possible, de la même façon que dans le TP 9, de commander les leds et de connaître leur état depuis le PC hôte.

On se rend donc bien compte de l’intérêt de la connectivité IP par SNMP qui permet un contrôle efficace à distance d’un système embarqué.