Maintenant que nous avons décrit les services et fonctionnalités du système d'exploitation, il nous reste à assembler tous les morceaux pour pouvoir utiliser Expresso sur le simulateur et sur le Palm m500. Nous allons commencer par étudier le procédé de compilation qui n'est pas si simple que pour un programme normal. Ensuite nous étudierons comment placer le système sur le simulateur (en ROM) ou sur le palm (en RAM).
Pour compiler l'ensemble des fichiers, comme nous travaillons sous linux, nous avons évidemment utilisé les makefiles. Nous
avons essayé de créer une organisation des makefiles pour faciliter le développement de nouveaux modules et le portage sur une autre
plateforme. L'organisation des makefiles est représenté avec la figure ![[*]](file:/usr/share/latex2html/icons/crossref.png){kind=icon}
Tout d'abord, la commande make menuconfig permet de configurer le hardware et les composants d'Expresso à installer. Cette commande génère le fichier .config qui est inclu dans le makefile principal. Le script Menuconfig qui génère ce fichier, génère aussi un fichier autoconf.h dans le répertoire include/Expresso qui contient les mêmes informations mais en un fichier header classique. Voici les choix possibles pour la configuration :
Une autre script génère toutes les dépendances entre fichiers. En effet, si on doit compiler un fichier C qui inclu un ensemble
de fichiers header, il faut pouvoir les localiser pour que la compilation se passe correctement. C'est le script mkdep qui
génère ces fichiers .depend dans tous les répertoires ou se trouvent des fichiers C grâce à la commande make dep.
Pour l'instant Expresso n'est disponible que sur un seul type d'architecture m68knommu, les motorola 68000 sans unité
de gestion de mémoire. Mais on pourrait très bien porter Expresso sur des PC ou toute autre architecture. Le makefile situé dans le
répertoire arch/m68knommu choisit la plateforme et le fichier Rules.make de la plateforme qui donne les informations
nécessaires pour cette plateforme.
Une fois tous ces fichiers correctement inclus les uns dans les autres, la variable $(SUBDIRS) contient l'ensemble
des répertoires à compiler càd notamment kernel, lib,
arch/m68knommu/kernel. L'étape suivante de la
compilation est d'exécuter les makefiles situés dans chacun des répertoires de la variable $(SUBDIRS). C'est donc le
makefile de chaque répertoire qui donne la commande de compilation de chaque fichier contenu dans Expresso mais ceci en utilisant
les paramètres fournis par l'organisation principale.
Une fois tous les fichiers compilés, le linker crée le fichier exécutable expresso. C'est à ce moment qu'intervient le fichier du linker ($(LINKFLAGS)) nous avons décrit dans la section précédente qui contient la carte mémoire. La variable $(HEAD) contient le fichier de démarrage de la plateforme, $(ARCHIVES) contient l'ensemble des fichiers compilé .o et $(LIBS) contient les bibliothèques utilisées. Voici la commande du linker :
La dernière chose à faire est de créer le fichier expresso.bin qui ne contient que les sections .text et .data de expresso et qui les concatène. Ceci est réalisé grâce à la commande :
Maintenant, que nous avons obtenu un fichier contenant Expresso, il faut encore le mettre en forme pour qu'il soit utilisable par l'émulateur Xcopilot. Comme nous l'avons déjà dit, Expresso s'éxécute dans la ROM de l'émulateur. Il suffit de fournir à Xcopilot un fichier pilot.rom de 1Mb. Pour ce faire, nous utilisons le script fixup.pl qui transforme expresso.bin en expresso.rom qui fait exactement 1Mb en lui ajoutant des 0. Pour finir, on copie expresso.rom dans xcopilot/pilot.rom. La commande est :
Il suffit ensuite de lancer Xcopilot qui execute directement Expresso.
L'installation sur une vraie machine Palm est un peu plus compliquée. Pour installer Expresso sur le Palm, nous avons deux solutions :
Nous avons réalisé la deuxième solution. Pour cela, nous avons utilisé un programme réalisé par Jeff Dionne qui s'appelle
PalmLoader. Etudions le fonctionnement de ce programme. PalmLoader est fondamentalement une application Palm. Cela signifie que nous
obtiendrons un fichier PRC qui pourra être envoyé et exécuté sur le Palm. Nous allons focaliser notre attention sur les
mécanismes qui se cachent derrière ce programme sans entrer dans les détails d'implémentation spécifiques au développement
d'application Palm. Pour plus de détails sur le développement d'applications Palm OS voir [#!PalmCompanion!#] et
[#!PalmReference!#].
La première étape se passe dans le makefile, il faut réussir à prendre le fichier
expresso.bin et le passer en argument de PalmLoader qui le copiera dans la mémoire du Palm. Pour cela, il faut
décomposer expresso.bin en différents fichiers de 4K, car c'est la taille des ressources de Palm OS, que l'on passe
à PalmLoader sous forme de différents fichier pagexxxx.bin.
Les fichiers pagexxxx.bin ainsi générés sont passés à PalmLoader par la commande suivante qui produit le fichier PRC:
Voyons maintenant le fonctionnement de PalmLoader. Une application Palm est fondamentalement une boucle infinie qui réceptionne
des évènements (programmation évènementielle). Une fois que l'utilisateur a cliqué sur le bouton principal, le code qui correspond
à cet évènement sera exécuté.
En réalité, les pages que l'on a passées à PalmLoader sont directement mises en mémoire lors de l'exécution de PalmLoader sur le Palm. L'organisation mémoire de Palm OS les place sous forme de ressources (base de données) dans la mémoire. D'abord on obtient l'accès aux ressources avec la fonction DmGetRessource. Cette fonction prend le nom d'une ressource et son numéro et renvoie un "handle". C'est un type de donnée qui est utilisé par le gestionnaire mémoire pour localiser une portion mémoire appelé "chunk".
![\fbox{\begin{minipage}{6cm}
\begin{footnotesize}
\texttt{hdl[i] = DmGetResource(...
...= (void *)0;\\
\hspace*{0,5cm} break;\\
\}
}
\end{footnotesize}\end{minipage}}](img83.png)
Ensuite, il faut bloquer ces parties de la mémoire (chunk) avec la fonction MemHandleLock qui renvoie un pointeur vers les données contenues dans le chunk et qui en réserve l'accès :
![\fbox{\begin{minipage}{8cm}
\begin{footnotesize}
\texttt{blk[i] = MemHandleLock(...
...lash n'',i);\\
\hspace*{0,5cm} break;\\
\}
}
\end{footnotesize}\end{minipage}}](img84.png)
Arrivé à ce stade, nous avons l'accès exclusif aux pages de notre système d'exploitation qui se trouvent dans la mémoire du Palm. Il faut à cet endroit inverser les pages car elles sont placées dans l'ordre inverse. C'est le but du code suivant qui utilise la fonction MC (memcopy) qui copie une portion de mémoire dans une autre :
La dernière chose à faire est de couper les interruptions en plaçant la valeur 0x2700 dans le registre de statut, de copier la première page de code en 0x400 et en 0x0000 pour que le vecteur d'interruption soit au bon endroit et le code de démarrage aussi puis de faire un saut du compteur de programme en 0x400.
Maintenant, Expresso tourne sur le Palm, il a l'accès total au hardware et s'exécute jusqu'à ce que l'utilisateur effectue un reset physique avec le bouton de reset.
Dans la section précédente, nous avons appris à compiler et installer Expresso sur différentes plateformes. Nous avons
donc déjà effectué une première configuration avec la commande make menuconfig. Dans un système d'exploitation
temps-réel, il est très important de pouvoir paramétrer de manière très fine le système. Certains paramètres comme la fréquence
d'horloge sont paramétrables dans les fichier headers. Mais pour le changement de la fréquence d'horloge, il faut faire extrèmement
attention de configurer les registres du processeur correctement pour générer la nouvelle fréquence.
Mais d'autres paramètres qui influencent la couche indépendante du hardware peuvent être configurés beaucoup plus facilement. Pour cela, il suffit de modifier le fichier config.h situé à la racine de l'arborescence de Expresso. Ces paramètres permettent de diminuer la taille du code du système ou des structures en mémoire, ce qui est très important vu les limites matérielles imposées par certaines plateformes. Nous avons déjà parlé de plusieurs de ces paramètres :
Pour créer une application fonctionnant sous Expresso, il suffit d'écrire son programme en C en utilisant les appels systèmes
offerts par Expresso. Il faut placer ce ou ces fichiers dans le répertoire applic et modifier le makefile avec
les noms de ces fichiers. Expresso considère que l'application est fournie sous forme du fichier application.o dans ce
même répertoire. Tout cela est évidemment configurable dans le makefile principal.
L'application doit contenir une fonction main() qui sera exécutée après l'initialisation dy système. En général,
cette fonction crée une tâche principale grâce à la fonction createTask() puis appele la fonction startScheduler
qui démarre l'ordonnanceur. La tâche principale peut ensuite créer des tâches, des sémaphores, etc.
Une fois l'application créée, il ne reste plus qu'a exécuter un make dans le répertoire principal d'Expresso et vous obtiendrez un fichier PRC ou un fichier .rom suivant la plateforme choisie.
