Chapitre 3 Description de l'architecture de la
plateforme TinyOS
utiliser un programme (comme Alien) pour installer les packages,
ou compiler directement à partir des sources. Le JDK de IBM est
nécessaire.
Par la suite, des packages supplémentaires peuvent
être ajoutés en passant par le site Source Forge, qui met à
disposition le code open source de TinyOS et d'un ensemble de programmes
dédiés.
3. Description du langage NesC
Il doit exister un environnement de développement logiciel
afin d'importer des applications sur les capteurs. Le langage utilisé
pour le développement dans TinyOS est le nesC.
Figure III. 3:symbole de langage
NesC
3.1 Présentation
Le langage NesC a une architecture basée sur des
composants. Cela permet de réduire la taille mémoire du
système et de ses applications, chaque composant correspondant à
un élément matériel du type LED ou timer par exemple. Les
composants peuvent être réutilisés dans n'importe quelle
application. L'implémentation des composants, dans le but
d'élaborer des applications, s'effectue en déclarant des
tâches, des commandes ou des évènements.
Les tâches sont utilisées pour effectuer la
plupart des blocs d'instruction d'une application. A l'appel d'une tâche,
celle-ci va prendre place dans une file d'attente de type FIFO pour y
être execute.
3.2 Concepts principaux dans NesC
Application: un ou plusieurs composants
reliés ensemble pour former un exécutable Composant
: un élément de base pour former une application nesC.
Il existe deux types de composants: modules et configurations
V' Module : composant qui implémente une
ou plusieurs interfaces
V' Configuration : composant qui relie d'autres
composants ensemble
Chapitre 3 Description de l'architecture de la plateforme
TinyOS
Interface : définie d'une manière
abstraite les interactions entre deux composants
3.3 Développement
Les interfaces spécifient un ensemble de fonctions,
appelées commandes, qui doivent être implémentées
par le fournisseur de l'interface et un ensemble de fonctions, appelées
évènements, qui doivent être implémentées par
l'utilisateur de l'interface. Afin de distinguer les fonctions concernant un
évènement de celles concernant une commande, les en-têtes
des fonctions sont précédés des mots-clés
respectifs event ou command. Voici un exemple simple
d'interface :
interface Timer {
command result_t start(char type, unit32_t
interval): command result_t stop();
event result_t fired();
}
TinyOS n'autorise pas les pointeurs de fonctions. Afin de
néanmoins proposer un mécanisme alternatif, NesC utilise des
interfaces paramétrées. Celles-ci permettent à
l'utilisateur de créer un ensemble d'interfaces identiques et d'en
sélectionner une seule à appeler grâce à un
identifiant.
interface SendMsg[unit8 t id]
Dans la pratique, NesC permet de déclarer deux types de
fichiers: les modules et les Configurations. Les configurations, permettent de
décrire les composants composites c'est-à-dire des composants
composés d'autres composants c'est à dire de granularité
supérieure. Une configuration permet donc de décrire
l'architecture. Une configuration est donc constituée de modules et/ou
d'interfaces ainsi que de la description des liaisons entre ces composants.
configuration NonModule {}
implementation {
//liste des modules et configurations utilises, ex :
components Main,Modulel ModuleN,Configl,
,ConfigiM ;
//descriptifs des liaisons
//Interface fournie <- Interface requise ou //Interface
requise -> interface fournie, ex : Main.StdControl -> Modulel.StdControl
; }
Chapitre 3 Description de l'architecture de la plateforme
TinyOS
Détaillons ici, quelques caractéristiques
concernant les configurations. La première d'entre elles concerne une
simplification. Lors du descriptif des liaisons, il est en effet possible de ne
pas préciser l'interface fournie par un module. Dans ce cas, elle
possédera le même nom que celle requise. L'autre
caractéristique concerne le composant Main. En effet, il est à
noter que ce composant est obligatoirement présent dans la configuration
décrivant l'ensemble de l'application car son rôle est de
démarrer l'exécution de l'application.
Les modules sont eux les éléments de base de la
programmation. Ils permettent en effet d'implémenter les composants et
sont stockés dans un fichier possédant la structure suivante :
module NomModuleM {
provides {
//liste des interfaces fournies, ex : interface
NominterfaceFourniel ; I
uses {
//liste des interfaces requises, ex :
interface NomlnterfaceRequisel ;
I
I
implimentation {
//déclarations des variables, ex :
int state ;
//implementations des fonctions décrites par les
interfaces fournies :
}
| 
