Tinyos

TinyOS est un système d’exploitation open-source conçu pour des réseaux de capteurs sans-fil. Il respecte une architecture basée sur une association de composants, réduisant la taille du code nécessaire à sa mise en place. Cela s’inscrit dans le respect des contraintes de mémoires qu’observent les réseaux de capteurs.

Pour autant, la bibliothèque de composant de TinyOS est particulièrement complète puisqu’on y retrouve des protocoles réseaux, des pilotes de capteurs et des outils d’acquisition de données. L’ensemble de ces composants peut être utilisé tel quel, il peut aussi être adapté à une application précise.

En s’appuyant sur un fonctionnement événementiel, TinyOS propose à l’utilisateur une gestion très précise de la consommation du capteur et permet de mieux s’adapter à la nature aléatoire de la communication sans fil entre interfaces physiques.

Sommaire 1 Propriétés de l’OS 2 Allocation de la mémoire 3 Structure logicielle 4 L’ordonnanceur TinyOS 5 Package TinyOS 6 Cibles possibles pour TinyOS 7 Sources et liens

Propriétés de l’OS

Propriété	Valeur pour TinyOS
Type	Event-driven
Disponibilité	Open-source
Langage	NesC
Préemptif	Non
Temps réel	Non
Sources	Fournies

Disponibilité et sources : TinyOS est un système principalement développé et soutenu par l’université américaine de Berkeley, qui le propose en téléchargement sous la licence BSD et en assure le suivi. Ainsi, l’ensemble des sources sont disponibles pour de nombreuses cibles matérielles.

Event-driven : Le fonctionnement d’un système basé sur TinyOS s’appuie sur la gestion des évènements se produisant. Ainsi, l’activation de tâches, leur interruption ou encore la mise en veille du capteur s’effectue à l’apparition d’évènements, ceux-ci ayant la plus forte priorité. Ce fonctionnement évènementiel (event-driven) s’oppose au fonctionnement dit temporel (time-driven) où les actions du système sont gérées par une horloge donnée.

Langage : Comme nous l’avons évoqué plus haut, TinyOS a été programmé en langage NesC que nous allons détailler plus loin.

Préemptif : Le caractère préemptif d’un système d’exploitation précise si celui-ci permet l’interruption d’une tâche en cours. TinyOS ne gère pas ce mécanisme de préemption entre les tâches mais donne la priorité aux interruptions matérielles. Ainsi, les tâches entre-elles ne s’interrompent pas mais une interruption peut stopper l’exécution d’une tâche.

Temps réel : Lorsqu’un système est dit « temps réel » celui-ci gère des niveaux de priorité dans ses tâches permettant de respecter des échéances données par son environnement. Dans le cas d’un système strict, aucune échéance ne tolère de dépassement contrairement à un système temps réel mou. TinyOS se situe au-delà de ce second type car il n’est pas prévu pour avoir un fonctionnement temps réel.

Consommation : TinyOS a été conçu pour réduire au maximum la consommation en énergie du capteur. Ainsi, lorsqu’aucune tâche n’est active, il se met automatiquement en veille.

Allocation de la mémoire

Il est important de préciser de quelle façon un système d’exploitation aborde la gestion de la mémoire. C’est encore plus significatif lorsque ce système travaille dans un espace restreint.

TinyOS a une empreinte mémoire très faible puisqu’il ne prend que 300 à 400 octets dans le cadre d’une distribution minimale. En plus de cela, il est nécessaire d’avoir 4 Ko de mémoire libre qui se répartissent suivant le schéma ci-contre.

• La pile : sert de mémoire temporaire au fonctionnement du système notamment pour l’empilement et le dépilement des variables locales.
• Les variables globales : réservent un espace mémoire pour le stockage de valeurs pouvant être accessible depuis des applications différentes.
• La mémoire libre : pour le reste du stockage temporaire.

La gestion de la mémoire possède de plus quelques propriétés. Ainsi, il n’y a pas d’allocation dynamique de mémoire et pas de pointeurs de fonctions. Bien sur cela simplifie grandement l’implémentation. Par ailleurs, il n’existe pas de mécanisme de protection de la mémoire sous TinyOS ce qui rend le système particulièrement vulnérable aux crash et corruptions de la mémoire.

Structure logicielle

Le système d’exploitation TinyOS s’appuie sur le langage NesC. Celui-ci propose une architecture basée sur des composants, permettant de réduire considérablement la taille mémoire du système et de ses applications. Chaque composant correspond à un élément matériel (LEDs, timer, ADC …) et peut être réutilisé dans différentes applications. Ces applications sont des ensembles de composants associés dans un but précis. Les composants peuvent être des concepts abstraits ou bien des interfaces logicielles aux entrées-sorties matérielles de la cible étudiée (carte ou dispositif électronique). L’implémentation de composants s’effectue en déclarant des tâches, des commandes ou des évènements. Nous allons détailler ceux-ci dans le tableau suivant :

Action	Utilisation
Tâche	Travaux de « longue durée ».
Commande	Exécution d’une fonctionnalité précise dans un autre composant.
Evènements	Equivalent logiciel à une interruption matérielle.

Les tâches sont utilisées pour effectuer la plupart des blocs d’instruction d’une application. A l’appel d’une tache, celle-ci va prendre place dans une file d’attente de type FIFO (First In First Out) pour y être exécutée. Comme nous l’avons vu, il n’y a pas de mécanisme de préemption entre les tâches et une tache activée s’exécute en entier. Ce mode de fonctionnement permet de bannir les opérations pouvant bloquer le système (inter-blocage, famine, …). Par ailleurs, lorsque la file d’attente des taches est vide, le système d’exploitation met en veille le dispositif jusqu’au lancement de la prochaine interruption (on retrouve le fonctionnement event-driven).

Les évènements sont prioritaires par rapport aux tâches et peuvent interrompre la tache en cours d’exécution. Ils permettent de faire le lien entre les interruptions matérielles (pression d’un bouton, changement d’état d’une entrée, …) et les couches logicielles que constituent les taches.

Dans la pratique, NesC permet de déclarer 2 types de composants : les modules et les configurations. Voici un second tableau récapitulatif :

Composant	Utilisation
Module	Contient le code d’un composant élémentaire.
Configuration	Permet de faire les liens entre différents modules.
Interface	Définit les entrées-sorties et le comportement d’un composant.

Les modules constituent les briques élémentaires de code et implémentent une ou plusieurs interfaces.

Une application peut faire appel à des fichiers de configuration pour regrouper les fonctionnalités des modules. Un fichier top-level configuration permet de faire le lien entre tous les composants.

Les interfaces sont des fichiers décrivant les commandes et évènements proposés par le composant qui les implémente. L’utilisation des mots clefs « Use » et « Provide » au début d’un composant permet de savoir respectivement si celui-ci fait appel à une fonction de l’interface ou redéfinit son code.

L’ordonnanceur TinyOS

Nous allons détailler le fonctionnement précis de l’ordonnanceur TinyOS qui est au cœur de la gestion des tâches et des évènements du système. Le choix d’un ordonnanceur déterminera le fonctionnement global du système et le dotera de propriétés précises telles que la capacité à fonctionner en temps réel.

L’ordonnanceur TinyOS c’est :

• 2 niveaux de priorité (bas pour les tâches, haut pour les évènements)
• 1 file d’attente FIFO (disposant d’une capacité de 7)

Par ailleurs, entre les tâches, un niveau de priorité est défini permettant de classer les tâches, tout en respectant la priorité des interruptions (ou évènements). Lors de l’arrivée d’une nouvelle tache, celle-ci sera placée dans la file d’attente en fonction de sa priorité (plus elle est grande, plus le placement est proche de la sortie). Dans le cas ou la file d’attente est pleine, la tâche dont la priorité est la plus faible est enlevée de la FIFO.

Package TinyOS

TinyOS est prévu pour fonctionner sur une multitude de plateformes, disponibles dès l’installation. En effet, TinyOS peut être installé à partir d’un environnement Windows (2000 et XP) ou bien GNU/Linux (Red Hat essentiellement, mais d’autres distributions sont également possibles).

Deux principales versions de TinyOS sont disponibles : la version stable (v. 1.1.0) et la version actuellement en cours de tests (v. 1.1.15); la première présente moins de risques mais est nettement moins récente. En outre, afin d’installer la dernière version de test, il est nécessaire de procéder d’abord à l’installation de la version 1.1.0.

Procédure d’installation :

• Windows : un guide propose l’installation de tous les principaux outils nécessaires au bon fonctionnement du système, notamment Cygwin (couche d'émulation de l'API Linux) qui permet d’avoir une interface Unix sous Windows. Le JDK Java 1.4 de Sun est nécessaire afin d’effectuer la procédure d’installation.

• GNU/Linux : des packages RPM sont proposés au téléchargement, un guide explique la marche à suivre. Les distributions Linux ayant un autre gestionnaire de paquet peuvent 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 SourceForge, qui met à disposition le code open source de TinyOS et d'un ensemble de programmes dédiés.

Cibles possibles pour TinyOS

Il existe de nombreuses cibles possibles pour ce système d’exploitation embarqué. Malgré leurs différences, elles respectent toutes globalement la même architecture basée sur un noyau central autour duquel s’articule les différentes interfaces d’entrée-sortie, de communication et d’alimentation. Voici un schéma représentant cette architecture :

Mote, processeur, RAM et Flash : On appelle généralement Mote la carte physique utilisant TinyOS pour fonctionner. Celle-ci a pour cœur le bloc constitué du processeur et des mémoires RAM et Flash. Cet ensemble est à la base du calcul binaire et du stockage, à la fois temporaire pour les données et définitif pour le système TinyOS.

Radio et antenne : TinyOS est prévu pour mettre en place des réseaux sans fils, les équipements étudiés sont donc généralement équipés d’une radio ainsi que d’une antenne afin de se connecter à la couche physique que constitue les émissions hertziennes.

LED, interface, capteur : TinyOS est prévu pour mettre en place des réseaux de capteurs, on retrouve donc des équipement bardés de différents types de détecteurs et autres entrées.

Batterie : Comme tout dispositif embarqué, ceux utilisant TinyOS sont pourvus d’une alimentation autonome telle qu’une batterie.

Voici une liste rapide des équipements supportés initialement par TinyOS dans sa version « tinyos-1.1.11-3is ».

ATMega8	AVRMote	Mica	Mica2
Micadot	Mica128	Micaz	MSP430
Rene2	Telos	Telos2	PC

Au delà de cette liste, il est possible d’implémenter tout type de plateforme embarquée physique en redéveloppant les bibliothèques nécessaires à la prise en compte des entrées sorties nécessaires. Ainsi, le lien suivant propose le résultat d’une thèse mettant en œuvre TinyOS sur un dispositif Freescale MC13192-EVB sur un réseau ZigBee :

Sources et liens

• Le site officiel de TinyOS
• Une distribution TinyOS en libre téléchargement
• Un très bon cours en Anglais sur le sujet
• Une thèse mettant en œuvre TinyOS sur un réseau de capteurs fonctionnant avec ZigBee
• Un premier exemple pour la prise en main de TinyOS et du langage NesC
• Les tutoriels officiels du site pour mieux comprendre TinyOS

• Portail des logiciels libres