Énoncé-Lab1

Département de génie électrique
ELE784 - Ordinateurs et programmation système
Laboratoire #1
Développement des composantes logicielles de base d’un système
informatique
Description sommaire :
Dans ce laboratoire, il vous sera demandez de mettre en place les différentes parties logicielles
d’un système informatique. À l’aide d’outils fournis durant les séances de laboratoire, vous
compilerez un noyau Linux pour un système informatique et vous compilerez les programmes
nécessaires pour travailler avec ce système. Le résultat final sera un système informatique
configuré avec Linux et qui sera utilisé par la suite afin de tester un pilote d’une caméra USB. Ce
pilote sera développé dans le cadre du laboratoire #2.
Professeur : Bruno De Kelper
Chargé de laboratoire : Louis-Bernard Lagueux
Objectif ............................................................................................................................... 3
Description de l’environnement de travail.......................................................................... 4
Ordinateurs des étudiants et client SSH.......................................................................... 4
Ordinateur de compilation .............................................................................................. 7
Les fichiers dans le répertoire home .......................................................................... 8
Les ports séries............................................................................................................ 9
Le protocole PXE........................................................................................................ 9
Les systèmes informatiques avec les caméras USB ..................................................... 10
Le système informatique........................................................................................... 10
La caméra USB ......................................................................................................... 11
Les étapes du laboratoire #1 ............................................................................................. 12
Récolte des informations............................................................................................... 12
Configuration du noyau Linux...................................................................................... 12
Compilation du noyau Linux ........................................................................................ 13
Compilation de busybox ............................................................................................... 14
Compilation du module UVC ....................................................................................... 15
Compilation du programme UVCCapture .................................................................... 15
Compilation de pingWatchdog ..................................................................................... 15
Génération du fichier compressé .................................................................................. 16
Création du répertoire ELE784 ......................................................................................... 17
Noyau et ramdisk « dummy »........................................................................................... 17
Récoltes des informations ................................................................................................. 18
Objectif
Le but ultime de la série de laboratoire de ce cours est de vous faire configurer un système
informatique avec un noyau Linux, d’y charger un module (pilote) que vous aurez développé pour
contrôler une caméra USB et d’utiliser les images générées par cette dernière afin d’effectuer
certains tests sur le processeur. De cette manière, il vous sera possible d’étudier la structure
fonctionnelle d’un ordinateur et ses différentes composantes avec un intérêt majeur sur
1
l’interaction matériel-logiciel (ceci est l’un des objectifs principales du cours ELE784).
L’ensemble du laboratoire sera divisé en trois parties:
1. Développement des composantes logicielles de base d’un système informatique. C’est
dans cette partie que vous configurerez le système informatique avec le noyau Linux et
avec certains outils couramment utilisés.
2. Développement d’un pilote pour contrôler une caméra USB sous Linux
3. Traitement des données obtenues avec la caméra pour démontrer l’importance de
l’interaction matériel-logiciel dans un système informatique.
Les objectifs du laboratoire #1 sont les suivants :
•
•
•
•
Se familiariser avec les différentes parties logicielles constituant un système
informatique.
Se familiariser avec les différentes étapes du développement d’un environnement de
travail pour un système informatique.
Se familiariser avec les différentes composantes d’un système d’exploitation
Se familiariser avec les différentes commandes Linux qui vous seront utiles dans les
laboratoires subséquents.
Nous débordons un peu de l’objectif général du cours mais ceci est inévitable compte tenu des
laboratoires subséquents. En effet, comment pourrions-nous développer et tester un pilote sans
même connaître les commandes de base du système d’exploitation qui est utilisé pour effectuer
les tests.
1
Adaptation du sommaire du cours que l’ont trouve sur le site du département de génie électrique
Description de l’environnement de travail
Avant de commencer la description des étapes de ce laboratoire, nous allons décrire
l’environnement de travail qui sera utilisé tout au long de la session. Cette étape est importante
car pour plusieurs d’entre vous, ce sera la première fois que vous travaillerez dans un tel
environnement.
Tel qu’illustré sur la figure 1, l’environnement se divise en 3 parties :
1. Les ordinateurs des étudiants avec un client SSH
2. L’ordinateur de compilation
3. Les systèmes informatiques avec les caméras USB.
Figure 1 Configuration du laboratoire
Ordinateurs des étudiants et client SSH
Il est important de noter que le laboratoire a été conçu de manière à vous permettre de travailler
à tout moment, que ce soit avec les ordinateurs des salles de cours de l’ÉTS ou avec votre
ordinateur personnel à la maison. Pour cette raison, il vous sera demandé de vous connecter à
un ordinateur sur lequel tous vos travaux pourront être effectués. Ceci vous évitera d’avoir à
installer Linux sur votre ordinateur personnel mais vous obligera à utiliser un client SSH. Ce
dernier est déjà installé sur les ordinateurs de l’ÉTS et vous pouvez vous le procurer, entre autre,
sur www.ssh.com.
Les étapes pour se connecter à l’ordinateur de compilation avec le programme SSH Secure
Shell sont les suivantes :
1. Démarrer le programme SSH Secure Shell et cliquer sur l’icône « Quick connect » en
haut à gauche.
Figure 2 Fenêtre du SSH Secure Shell
2. Dans la fenêtre « Connect to Remote Host » insérer l’adresse du serveur dans l’espace
« Host Name » et votre nom d’usager dans l’espace « User Name ». Ces informations
vous seront données lors de la première séance de laboratoire. Notez les biens car elles
vous suivront tout au long de la session.
Figure 3 Entrer le « Host Name » et le « User Name »
3. Finalement, il vous sera demandé d’insérer votre mot de passe. Ce dernier vous sera
aussi donné lors de la première séance de laboratoire.
Figure 4 Entrer le mot de passe
Une fois que vous serez connecté au serveur, la première chose que vous devrez faire sera de
changer votre mot de passe afin de protéger vos travaux contre la copie. Pour ce faire, il suffit
d’utiliser la commande passwd. Il vous sera demandé d’insérer votre mot de passe actuel et par
la suite votre nouveau mot de passe à deux reprises. Choisissez bien ce dernier ! Si vous
oubliez votre mot de passe, vous devrez demander au chargé de laboratoire, durant les séances
de laboratoire, de le réinitialiser.
Figure 5 Changer le mot de passe
Si vous voulez transférer des fichiers entre votre poste et l’ordinateur de compilation, vous devrez
utiliser le programme SSH Secure File Transfert (ce programme est installé en même
temps que le SSH Secure Shell). Pour le démarrer à partir du SSH Secure Shell,
sélectionnez « New File Transfer » du menu « Window ». La fenêtre suivante s’ouvrira et vous
aurez accès aux fichiers sur l’ordinateur de compilation (la fenêtre de droite) et à vos fichiers sur
votre poste (la fenêtre de gauche). Il suffit de cliquer avec le bouton de droite sur le bon fichier et
de faire un « Upload » ou un « Download » selon le cas.
Figure 6 Fenêtre du SSH Secure File Transfer
Normalement, c’est tout ce que vous aurez à faire à partir de votre ordinateur personnel car
toutes les opérations subséquentes s’effectueront à partir de ce client SSH. Par contre, certains
d’entre vous désirerons utiliser des programmes avec des interfaces graphiques pour effectuer
certaines tâches. Pour cette raison, le serveur SSH a été configuré afin de permettre les tunnels
X11 entre les clients et l’ordinateur de compilation. Par contre, si vous voulez utiliser cette
option, vous devrez avoir un serveur X installé sur votre ordinateur.
Dans les laboratoires du département, le programme X-Win32 est installé et fonctionne très bien.
Pour l’utiliser il suffit de le démarrer en sélectionnant « Start/Win32 5.4/X-Win32 » du menu de
Windows. Si vous voulez effectuer la même opération à partir de votre ordinateur personnel,
plusieurs serveurs X gratuit sont disponibles sur Internet. Voici une liste de certains d’entre eux:
•
•
•
Xming (http://sourceforge.net/projects/xming)
Cygwin/X (http://x.cygwin.com)
Linux Terminal Server (http://www.linuxtsc.org)
Il importe à vous de faire le choix de votre serveur X et de l’installer. Aucun support ne vous sera
fourni par le chargé de laboratoire pour effectuer cette étape. De plus, il est important de noter
que les performances de ce protocole aux travers d’Internet ne sont pas aussi intéressantes que
sur un réseau local et pour cette raison, il vous ait conseillé d’utiliser les programmes graphiques
à partir des laboratoires de l’école uniquement.
Finalement, pour utiliser un tunnel X11 avec le programme SSH Secure Shell, Il faut que ce
dernier soit bien configuré. Pour ce faire, sélectionnez « Settings… » du menu « Edit » pour
accéder aux options de configuration du client SSH. Assurez-vous que la case « Tunnel X11
Connections » soit sélectionnée dans le menu « Profile Settings / Tunneling »
Figure 7 Configuration du tunnel X11
Et voilà, le client est configuré. Il ne vous reste plus qu’à lancer un programme sur l’ordinateur de
compilation et ce dernier sera automatiquement affiché sur votre ordinateur de travail.
Ordinateur de compilation
C’est sur cet ordinateur que la totalité des travaux seront exécutés. Des comptes utilisateurs ont
été créés pour chaque équipe et tous les fichiers nécessaires pour effectuer le laboratoire seront
disponibles dans le répertoire ELE784 de votre home (répertoire dans lequel vous vous
connectez par défaut avec le client SSH). Cet ordinateur est utilisé, dans le cadre de ce cours,
pour compiler tous vos programmes et noyaux. Puisqu’il est possible que plusieurs équipes
lancent des compilations en même temps, nous avons fait notre possible pour mettre à votre
disposition un ordinateur qui saura répondre aux besoins du cours. Notre choix s’est donc arrêté
sur la configuration suivante:
•
•
•
•
•
•
Carte mère Supermicro X7DA3
2 processeurs Intel Xeon Dual Core 2.6Ghz
1 Gb DDRII 667 Mhz
Disque dur Seagate 73Gb SAS 15K RPM
2 ports ethernet Gigabit
Carte Octopus-550 de Lava (8 ports séries)
Les fichiers dans le répertoire home
Comme nous l’avons déjà dit, le répertoire ELE784 dans votre home contient déjà tous les
fichiers nécessaires pour le laboratoire. Chaque élément de ce répertoire à une utilité bien
précise qui est résumé dans ce qui suit:
$home/ELE784/busybox-1.12.0
Dans ce répertoire ce trouve les fichiers sources de
busybox (exécutable de base pour système embarqué).
$home/ELE784/linux-2.6.21.1
Dans ce répertoire ce trouve les fichiers sources du
noyau Linux qui seront utilisés pour le laboratoire #1.
$home/ELE784/myModule
C’est dans ce répertoire que vous devez créer votre
module (pilote) pour l’utilisation de la caméra USB
$home/ELE784/myProgTest
C’est dans ce répertoire que vous devez créer le
programme de test qui sera utilisé pour tester le module
(pilote) de la section #2
$home/ELE784/myWatchdog
C’est dans ce répertoire que vous trouvez tous les
sources nécessaires pour le watchdog
Répertoire utilisé pour « mounter » le ramdisk afin qu’il
soit peuplé avec le script mkrootfs.sh. Ce répertoire
est normalement vide
$home/ELE784/ramdisk
$home/ELE784/rootfs
C’est dans ce répertoire que le script mkrootfs.sh
crée le système de fichier destiné au système
informatique avant de le compresser.
$home/ELE784/scripts
Dans ce répertoire se trouve les scripts utilisés au court
du laboratoire
$home/ELE784/src
Dans ce répertoire vous pouvez trouver les sources des
programmes utilisés dans ce laboratoire.
$home/ELE784/uvc
Module officiel pour le périphérique compatible UVC. Il
sera utilisé pour tester le matériel avant que votre module
ne soit codé
$home/ELE784/uvccapture-0.4
Petit programme pour utiliser avec le module UVC. Il
prend une simple photo.
C’est dans ce répertoire que le script mkrootfs.sh
copie le noyau et le ramdisk.
$home/ system
Les ports séries
Nous avons doté cet ordinateur d’un total de 10 ports séries. Les données affichées par les
systèmes informatiques seront donc récupérées par ces ports. À chaque équipe sera attribué un
port qui sera relié à son système informatique. Plusieurs programmes peuvent être utilisés pour
lire ou écrire des données sur ces ports tels que picocom (utilitaire vraiment simple) minicom
(utilitaire beaucoup plus complexe) ou gtkterm (utilitaire graphique, clone de hyperterminal). Le
choix de l’utilitaire est laissé a l’étudiant mais à titre d’exemple, voici comment travailler avec
picocom.
Pour démarrer picocom et configurer le port par la même occasion il faut utiliser la commande
suivante :
user@ELE784Head:~$ picocom –b 115200 /dev/ttyS0
Cette commande configure le port ttyS0 (l’équivalent du COM0 de Windows ou Dos) à 115200
bauds.
Une fois que vous avez terminé, vous pouvez quitter l’utilitaire en appuyant sur CTRL + a + q
en même temps. En principe, c’est tout ce que vous avez à connaitre pour travailler avec ce
programme. Par contre, si vous voulez connaitre les autres options et commandes de picocom,
je vous réfère à la page du manuel accessible avec la commande :
user@ELE784Head:~$ man picocom
Le protocole PXE
Afin de minimiser les manipulations directes avec le système informatique, le protocole PXE
(« Preboot Execution Environment ») sera utilisé dans ce laboratoire. Ce protocole permet, entre
autre, à un système informatique de récupérer une image d’un système et de le télécharger pour
l’exécuter. Avec ce protocole, un serveur DHCP est utilisé pour récupérer les informations de
base comme l’emplacement des fichiers nécessaires et ces derniers sont transférés à l’aide du
protocole TFTP. L’ordinateur de compilation est donc configuré avec un serveur DHCP qui
fonctionne uniquement avec le réseau ethernet des systèmes informatiques et d’un serveur TFTP
sur lequel vous copierez le noyau et le système de fichier que vous aurez généré. Sur le
diagramme qui suit, vous pouvez voir un résumé des étapes qui sont automatiquement
effectuées à chaque fois que le système informatique est démarré.
Système
Informatique
Ordinateur de
compilation
Requête DHCP
Réponse DHCP (Information réseau et chemin du fichier
pxelinux.0)
Requête pour la récupération du fichier pxelinux.0 par TFTP
Transfert du fichier pxelinux.0 par TFTP
Exécution du fichier pxelinux.0
Requête pour la récupération du fichier de configuration par TFTP
Transfert du fichier de configuration par TFTP
Requête pour la récupération du noyau et du ramdisk indiqué par
le fichier de configuration par TFTP
Transfert du noyau et du ramdisk par TFTP
Décompression du noyau et du ramdisk et exécution du
noyau
Figure 8 Séquence des échanges entre un client et un serveur avec le protocole PXE
Mis à part de copier votre noyau et votre ramdisk au bon endroit sur l’ordinateur de compilation
(ce qui est effectué par le script mkrootfs.sh), vous n’aurez pas à interagir dans cette étape.
Les systèmes informatiques avec les caméras USB
Le but du laboratoire #1 est de créer un noyau pour un système informatique qui sera utilisé, plus
tard, afin de contrôler une caméra USB. Dans les lignes qui suivent, le matériel utilisé pour ces
deux éléments vous sera présenté. Les systèmes informatiques ont été fixés dans une armoire
qui sera dans le local du laboratoire. En temps normal, vous ne devriez pas avoir à les manipuler
directement.
Le système informatique
Le système informatique utilisé comme destination (« target »), est un « Single Board Computer »
(SBC) de la compagnie Kontron. Il est équipé, en autre, des éléments suivants :
•
•
•
•
•
•
•
•
Processeur Pentium III de Intel cadencé à 850 MHz
32 Mb RAM
Interface Ethernet
Carte vidéo
Ports séries
Ports USB
Port parallèle
Interface pour lecteur de disquette
•
•
•
Bus IDE
Interface PS/2
Interface pour CompactFlash
Les marques et modèles de chaque périphérique ont été intentionnellement omis puisque vous
devrez en faire la recherche dans la première partie de ce laboratoire. Dans le cadre de ce
projet, nous n’aurons pas besoin de tous ces périphériques. Lorsque vous configurerez votre
noyau, nous vous indiquerons les éléments qui devront être initialisés au démarrage.
Figure 9 Système informatique utilisé dans le cadre de ce laboratoire
La caméra USB
La caméra utilisée est la Logitech QuickCam Orbit MP que vous pouvez voir sur l’image suivante.
Cette dernière permet, en plus de filmer, d’être contrôlé afin d’orienter la lentille vers un nouvel
objectif. Le pilote que vous développerez dans le laboratoire #2 devra fournir les interfaces
nécessaires afin de contrôler cette caméra en plus de permettre la prise de photo. Par contre,
afin de tester le matériel dès la première partie de ce laboratoire, vous devrez compiler le module
(pilote) UVC officiel. Ce dernier, à l’aide du programme uvccapture, vous permettra de prendre
une photo et valider le fonctionnement du matériel, mais il ne permet pas de diriger la caméra.
Figure 10 La caméra Orbit MP de Logitech utilisée dans ce laboratoire
Les étapes du laboratoire #1
Dans cette section, il sera expliqué comment procéder afin d’obtenir le résultat final du laboratoire
#1. La première étape va consister à récolter certaines informations concernant le système
informatique. Ensuite, ces informations seront utilisées pour configurer et compiler le noyau
Linux. Par la suite, différents outils seront compilés pour finalement former une image
compressée du système de fichier qui sera transmit au système informatique en même temps
que le noyau.
Récolte des informations
La première étape du laboratoire sera de récolter les informations des périphériques que nous
voulons initialiser avec le noyau Linux. Certains périphériques inclus sur le SBC ne seront pas
nécessaires pour ce projet, ils seront donc laissés de côté. Par contre, rien ne vous empêche de
les configurer. Toutefois, soyez certain qu’une fois initialisé, ils ne causeront pas de problème.
À l’aide des documents fournis par le chargé de laboratoire, trouvez les informations suivantes :
•
•
•
•
Modèle de l’interface Ethernet
Le type du bus USB (EHCI, ISP116X, OHCI, UHCI)
Le chipset utilisé sur système informatique
Quels bus sont disponibles (ISA, PCI,…)
De plus, veuillez dresser une liste des périphériques standard présents sur le système
informatique qui devront être initialisés (port série, port parallèle, etc…).
Une petite fiche est présente à la fin de ce document. Cette dernière devra être complétée par
l’équipe et rendu au chargé de laboratoire à la date fixée au début de la session.
Configuration du noyau Linux
Une fois les informations récoltées, il faut configurer le noyau Linux en fonction de ces données.
Pour ce faire commencez par vous placer dans le répertoire où les sources du noyau sont
décompressées et ensuite, lancer la configuration avec les commandes suivantes :
user@ELE784Head:~$ cd ~/ELE784/linux-2.6.21.1
user@ELE784Head:~$ make menuconfig
Ceci affichera un menu avec lequel vous serez en mesure de sélectionner ou de désélectionner
ce que vous voulez ajouter à votre noyau ou enlever à celui-ci. Certaines sections ont déjà été
configurées mais vous devrez en configurer d’autres. Une fois cette étape terminée, prenez le
temps de naviguer dans les différents menus de ce programme de configuration afin de connaître
la variété des options offertes par le noyau Linux. Vous pouvez toujours obtenir de l’information
sur une option en particulier en vous positionnant sur cette dernière et en choisissant « Help »
dans le bas de l’écran (pour sélectionner l’une des trois options du bas (« Select », « Exit » et
« Help ») utilisez la flèche de gauche et celle de droite sur le clavier ou encore la touche « tab »).
•
Commencez par ajouter le support des ramdisk initial dans le noyau (« Initial RAM
filesystem and RAM disk (initramfs/initrd) support ») ceci vous permettra d’utiliser un
ramdisk comme système de fichier principale avec tous les droits nécessaires au
démarrage.
•
Ensuite, permettez l’insertion et le retrait des modules et ajouter l’option « Forced module
unloading » au cas où vous auriez des problèmes dans les autres étapes du laboratoire.
•
Choisissez la bonne famille d’architecture dans le menu « Subarchitecture Type
(XXXXXXXXXXXXX) ---> » et le bon type de processeur dans le menu « Processor
family (XXXXXXXXXXXXX) ---> ».
•
Par la suite, selon ce que vous avez trouvez dans la section précédente, ajouter le
support des bus dans le menu « Bus options (PCI, PCMCIA, EISA, MCA, ISA) »
•
Il est maintenant temps de configurer les différentes composantes présents sur le SBC
que vous avez trouvées dans la section précédente. Pour se faire suivez les étapes
suivantes :
•
Ajouter le bon support pour le périphérique réseau dans le menu « Device drivers
/ Network Device Support / Ethernet (10 or 100Mbit) »
•
Ajouter le bon type de bus USB dans le noyau avec le menu « Device drivers /
USB Support »
•
Ajouter le support du chipset
ATA/ATAPI/MFM/RLL support »
•
Finalement dans le menu « Block devices ---> », configurez votre noyau pour
qu’il permettre la création de 1 ramdisk avec une grandeur par défaut à 8192
bytes et des bloques de 1024 bytes.
•
S’il y a d’autres périphériques que vous jugez bon d’ajouter dans le noyau, faite
le maintenant. Encore une fois, soyez certain qu’ils n’auront aucune influence
nuisible sur le reste du système.
dans
le
menu
« Device
drivers
/
•
Ajouter le support pour le système de fichier EXT2 (« Second extended fs support ») et
les attribus étendu (« Ext2 extended attributes ») dans le menu « File systems ---> ».
•
Finalement, ajouter le support pour le « NFS file system support » dans le menu « File
systems/ Network File Systems ». Ajouter tous les options possibles pour ce support.
Compilation du noyau Linux
La compilation du noyau Linux est très simple. Il suffit d’utiliser la commande suivante :
user@ELE784Head:~$ make
Ceci démarrera la compilation qui sera, en fonction du nombre d’utilisateur qui compile en même
temps, plus ou moins longue. Une série d’information défilera à l’écran et il peut être intéressant
d’y jeter un coup d’œil afin d’être certain qu’il n’y est pas d’erreur. Le résultat final sera un noyau
compressé
nommé
bzImage
situé
dans
le
répertoire
~/ELE784/linux2.6.21.1/arch/i386/boot. Ce fichier sera copié plus tard, par le script mkrootfs.sh,
dans le répertoire du serveur TFTP afin qu’il puisse être utilisé, avec le protocole PXE, par votre
système informatique.
Compilation de busybox
Le but de busybox est de combiner dans un seul exécutable plusieurs utilitaires de base
(fileutils, shellutils, etc…) que l’ont retrouve avec une installation Linux normal. Il intègre
uniquement les options les plus importantes de chaque utilitaire. Ceci permet d’obtenir une
installation occupant beaucoup moins d’espace disque. Avec ce programme, nous obtenons
donc tous les commandes que nous aurons besoin pour naviguer dans notre système et pour
exécuter nos programmes de test.
La compilation de cet outil s’effectue avec les étapes suivantes :
•
Placez-vous dans le bon répertoire et lancer la configuration de busybox avec les
commandes suivantes :
user@ELE784Head:~$ cd ~/ELE784/busybox-1.6.1
user@ELE784Head:~$ make menuconfig
Ceci ouvrira un menu similaire à celui que vous avez vu pour la configuration du noyau
Linux.
•
L’outil est déjà en bonne partie configuré mais, il reste certaines parties à configurer (il
est important de noter que, de façon identique à la configuration du noyau Linux, il est
possible d’obtenir des informations sur chaque item d’un menu et en le sélectionnant et
en choisissant « Help » dans le bas de l’écran) :
o
Dans le menu « Coreutils » ajouter les commandes chgrp, chmod et chown qui
sont utilisées pour gérer les droits des utilisateurs sur les fichiers. Ajouter aussi
les commandes cp et rm qui sont utilisées pour copier et effacer des fichiers.
Finalement ajouter la commande ls qui sert à lister le contenu d’un répertoire
(l’équivalent du dir de Windows ou Dos).
o
Dans le menu « Console utilities » ajouter la commande clear qui sert à effacer
le contenu de l’écran (équivalent du cls de Windows ou Dos).
o
Dans le menu « Init utilities » ajouter le programme Init qui est le premier
programme à être exécuter sur un système Linux. C’est lui qui s’occupe
d’initialiser le système une fois que le noyau est démarré.
o
Dans le menu « Linux Module Utilities » ajouter les commandes insmod, rmmod
et lsmod. Ces commandes servent à charger un module, à retirer un module et
à obtenir la liste des modules chargés dans le système.
o
Dans le menu « Linux System Utilities », ajouter la commande dmesg qui sert à
afficher le log des messages du noyau. Cette commande vous sera utile pour
vérifier si tout a bien été initialisé au démarrage du noyau.
o
Dans le menu « Networking Utilities » ajouter le programme httpd qui est un
serveur web que nous utiliserons afin de visualiser les images captées avec la
caméra USB. De plus, il faut ajouter telnetd qui est le serveur telnet afin de
pouvoir se connecter à distance sur le SBC
o
•
Dans le menu « Process Utilities » ajouter la commande ps qui sert à obtenir la
liste des programmes qui roule en arrière plan sur le système.
Une fois configuré, il faut lancer la compilation avec la commande suivante :
user@ELE784Head:~$ make
•
Finalement, avec la compilation terminée, il faut lancer l’installation locale. Pour ce faire
il faut utiliser la commande suivante :
user@ELE784Head:~$ make install
Ceci copiera tous les fichiers nécessaires à busybox dans le sous répertoire _install
et créera tous les liens vers l’utilitaire principale. Je conseil fortement à tous les étudiants
d’aller jeter un coup d’œil sur la structure de répertoire qui a été créée dans cette étape.
Avec le script utilisé dans la dernière section, tous ces fichiers seront copiés dans le
système de fichier final mais pour l’instant, nous avons fini avec busybox.
Compilation du module UVC
Pour la compilation du module UVC, il n’y a pas de manipulation particulière à effectuer, il faut
simplement lancer la compilation avec les commandes suivantes :
user@ELE784Head:~$ cd ~/ELE784/uvc
user@ELE784Head:~$ make
Ceci démarrera la compilation et, si votre noyau est bien configuré, il ne devrait pas y avoir de
message d’erreur. Si il y a une erreur, c’est certainement parce qu’il manque certains éléments à
votre noyau. Il suffit alors de bien lire le message d’erreur afin d’identifier le problème et
retournez à la configuration du noyau afin d’ajouter les éléments qui manquent.
Compilation du programme UVCCapture
Encore une fois, cette étape est bien simple. Il suffit d’utiliser les commandes suivantes pour
compiler ce programme et d’obtenir l’exécutable uvccapture :
user@ELE784Head:~$ cd ~/ELE784/uvccapture-0.4
user@ELE784Head:~$ make
Compilation de pingWatchdog
Ce programme est utilisé pour faire un « ping » au watchdog de la carte. Ce dernier, s’il ne le
reçoit pas, effectuera un reset sur le system. De cette manière, si vous avez des problèmes avec
la configuration de votre système, ce dernier se réinitialisera par lui-même. Pour compiler ce
programme, il suffit d’effectuer la commande suivante :
user@ELE784Head:~$ cd ~/ELE784/myWatchdog
user@ELE784Head:~$ gcc pingWatchdog.c
Génération du fichier compressé
À cette étape, nous avons tout ce qu’il nous faut pour travailler avec le système informatique.
Voici un résumé de ce que nous avons obtenu :
•
•
•
•
•
Un noyau Linux dans le répertoire ~/ELE784/linux-2.6.21.1/arch/i386/boot
Un exécutable avec plusieurs liens pointant vers lui pour busybox dans le répertoire
~/ELE784/busybox-1.6.1/_install
Un module pour la caméra compatible UVC dans le répertoire ~/ELE784/uvc
Un
programme
pour
utiliser
avec
ce
module
dans
le
répertoire
~/ELE784/uvccapture-0.4
Un programme pour faire les « ping » au watchdog
Il faut maintenant former la série de répertoires de base utilisée par un système Linux et y ajouter
tout ces éléments (à l’exception du noyau qui sera transmis séparément) afin d’obtenir le
système de fichier final. Ce dernier sera compressé et sera par la suite envoyé au système
informatique pour être utilisé comme ramdisk.
Pour ce faire, un script (mkrootfs.sh) a été créé. Pour l’exécuter, il faut utiliser la commande
suivante :
user@ELE784Head:~$ sudo ~/ELE784/scripts/mkrootfs/mkrootfs.sh
Lorsque ce script aura terminé d’être exécuté, vous devriez avoir le noyau et l’image du ramdisk
dans le répertoire du serveur TFTP. Il ne vous reste plus qu’à démarrer la carte et de vérifier que
votre noyau fonctionne convenablement.
Création du répertoire ELE784
Si, par un malheureux hasard, vous trouvez que votre répertoire $HOME/ELE784 devient trop
corrompue (trop de modifications ont été effectuées pour que vous puissiez revenir en arrière), il
est possible de le recréer. Par contre, il faut faire attention car toutes les données
contenues dans ce répertoire et ses sous répertoires seront perdues. Donc, avant
d’effectuer ces étapes, copier tous les fichiers que vous ne voulez pas perdre. Ceci est très
important car dans les systèmes UNIX/Linux, il n’est pas possible de récupérer un fichier qui
a été effacé.
Une fois les fichiers que vous ne voulez pas perdre bien copier dans un autre répertoire que
$HOME/ELE784, effectuer les étapes suivantes :
user@ELE784Head:~$
user@ELE784Head:~$
user@ELE784Head:~$
user@ELE784Head:~$
user@ELE784Head:~$
cd ~
rm –rf ELE784
cp ../ELE784.tar.gz .
tar –zxvf ELE784.tar.gz
rm ELE784.tar.gz
Ceci effacera l’ancien $HOME/ELE784 pour ensuite le recréer à l’aide de l’archive compressée
ELE784.tar.gz.
Noyau et ramdisk « dummy »
Afin de tester si votre système informatique est alimenté. Un noyau « dummy » et un ramdisk
« dummy » ont été créé. Ce noyau n’initialise presque aucun périphérique et permet uniquement
de voir certaines informations défilées sur le port série. De plus, puisque le watchdog ne sera
jamais réinitialisé, le système bouclera constamment dans sont cycle de démarrage. Pour utiliser
ces fichiers, utiliser les commandes suivantes :
user@ELE784Head:~$ cd ~
user@ELE784Head:~$ cp ../bzImage.dummy ~/system/bzImage
user@ELE784Head:~$ cp ../ramdisk.img.gz.dummy ~/system/ramdisk.img.gz
Si votre système n’est pas en cycle de démarrage, effectuer la commande reboot pour le faire
redémarrer.
Récoltes des informations
Cette fiche devra être complétée par l’équipe et remis au chargé de laboratoire avant la date indiquée au
début du laboratoire.
Modèle de l’interface Ethernet :
Le type du bus USB :
Le chipset utilisé sur système informatique :
Quels bus sont disponibles:
Quels sont les autres périphériques présents sur le SBC?