Tiny os

TINYOS: SYSTÈME D’EXPLOITATION
POUR RÉSEAUX DE CAPTEURS SANS
FILS
Présenté par :
SAKIRDA Wijdane
HASSANI IDRISSI Adil
ZARBOUBI Mohamed
Encadré par :
M.JENKAL
MASTER SPÉCIALISÉ
FILIÈRE : SYSTÈMES EMBARQUÉS ET INGÉNIERIE BIOMÉDICALE
MODULE :RÉSEAUX DE CAPTEURSSANS FILS
Année Universitaire 2020 – 2021
Le Lundi 01 Février 2021

Plan
1. Introduction
2. PropriétésTinyOS
3. Gestion des processus
4. Gestion de la mémoire
5. Gestion des interruptions
6. Langage NesC
7. Exemple application Blink.nc ?

1. Introduction
 Réseaux de capteurs sans fil :
 Capables de recevoir et de transmettre des données d'une manière autonome
 Disposés d’une alimentation autonome
 Durée de vie de batterie est limitée
Un système d’exploitation spécialisé pour fonctionner sur ce type
de réseau de capteurs tout en respectant ses contraintes.

 Évènementiel
Le fonctionnement d’un
système basé surTinyOS
s’appuie sur la gestion des
évènements se
produisant.
 Non préemptif
TinyOS ne gère pas ce
mécanisme de préemption
entre les tâches mais donne
la priorité aux interruptions
matérielles.
2. Propriété deTinyOS

 Pas de temps réel
Un système strict, aucune
échéance ne tolère de
dépassement.TinyOS se situe au-
delà de ce 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.
2. Propriété deTinyOS

A. Ordonnancement :
L’ordonnanceurTinyOS comporte :
o Deux niveaux de priorité (bas pour les tâches, haut pour les évènements)
o Une file d’attente FIFO (disposant d’une capacité de 7 places)
 L’appel d’une tache : prend place dans la file d’attente pour y être exécutée.
 La file d’attente des taches est vide : le dispositif est en veille
 La file d’attente est pleine : la tâche dont la priorité est la plus faible est enlevée.
 Priorité des évènement : peuvent interrompre la tache en cours d’exécution

B. Communications et synchronisation:
 Communications par Messages : la boîte aux lettres ou BAL : le message
est placé en mémoire par l'émetteur et il est récupéré depuis cette case
par le récepteur.
 Communication par zone commune: dispose d'une zone de mémoire
commune où les données sont disposées en libre accès.
Le problème que pose ce type de communication est la synchronisation entre
les processus.

Concernant la synchronisation, le systèmeTinyOS fournit plusieurs outils, on cite :
 Synchronisation par Rendez-vous: Un rendez-vous unilatéral est un point où
un processus se synchronise avec quelque chose d'externe, sans que l'agent
extérieur ait besoin de se synchroniser avec ce processus.
 Synchronisation par événements : le mécanisme de drapeaux événements
(event flags) signale aux processus qu'un événement asynchrone (event) s'est
produit.

Gestion de la mémoire surTinyOS
 En général dans un système embarqué :
 allocation mémoire statique:
 Éviter « Memory Overflow »
 Éviter utilisation d’algorithmes d'allocation mémoire compliqués nécessitant
beaucoup de temps de calcul.
 Contrainte : le système est embarqué et donc doté d’une mémoire réduite;
ne pouvant pas contenir le OS ainsi que les programmes en même temps.

 TinyOS occupe un espace mémoire très
faible:
 300 à 400 octets (distribution minimale)
 4 Ko de mémoire libre :
 La pile : mémoire temporaire pour le
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.

 Spécificités du modèle mémoire duTinyOS :
 Allocation non dynamique de la mémoire (statique):
 Absence du tas (heap)
 Absence de pointeurs sur fonctions
 Variables locales :
 Stockées sur la pile
 Variables globales :
 Disponibilité par trame
 Conservation de mémoire
 « Flat Memory » : l’espace mémoire est une seule et
même zone

Gestion des interruptions
 La gestion des interruptions est d'une grande importance.
 TinyOS est non préemptif == ne gère pas les interruptions entre tâches
 Priorité aux interruptions matérielles qui peuvent à tout moment stopper
l’exécution d’une tâche.
 L'interaction avec l'environnement se fait à travers des interruptions.
 Le systèmeTinyOS est aussi appelé système piloté par interruptions
(Interrupt Driven System)
– grande partie du traitement se fait durant les ISRs
– passe la plupart de son temps dans un mode basse-énergie.

Gestion des interruptions
 Changement de contexte :
 Utilisation des masques d’interruption
 Prise en compte que des interruptions urgentes
 Autres interruptions pour plus tard, dans le cas où plusieurs interruptions ont lieu
Tâche courante
Routine de Service
d’Interruption
(ISR)
Ancienne tâche
Latence Latence

Définition de nesc
14
NesC est un langage de programmation dérivé du langage C, fait pour minimiser
l’utilisation de mémoire et de puissance de calcul par les capteurs, qui très
souvent disposent de ressources très limitées (batterie de faible puissance et non
changeable, mémoire réduite...)

Définition de nesc
15
Il est ainsi essentiellement dédié pour la réalisation de systèmes embarqués
distribués. Il cible en particulier l’implémentation d’applications pour les réseaux
de capteurs. Il offre donc une réactivité importante vis-à-vis de l’environnement,
Il propose de nombreuses optimisations pour diminuer l’occupation de l’espace
mémoire.

Définition de nesc
16
NesC permet la décomposition d’une application en « modules » réutilisables en
fournissant d’abord trois abstractions de programmation :
les interfaces
 les modules
 les configurations

Définition de nesc
17
L'unité de code de base de nesC est
le composant "component"
Component
A
Component
B
Component D
Component
C
Application
configuration
Component
E
Component F

Définition de nesc
18
Composant

Définition de nesc
19
• module MyAppM {
• provides interface
StdControl;
• uses interface ADC;
• uses interface Timer;
• uses interface Send;
• }
• implementation {
• …
• }
interface StdControl {
command void init();
command void start();
command void stop();
}
interface ADC {
command void getData();
event void dataReady(int data);
}
interface Timer {
command void start(int interval);
command void stop();
event void fired();
}
interface Send {
command void send(TOS_Msg *m);
event void sendDone();
}

Définition de nesc
20
TinyOS/nesC Basic Concepts 20
module ModuleName {
provides interface StdControl;
provides interface I1;
}
implementation {
// ========== FRAME =========
uint8_t count=0;
// ========== FUNCTIONS =====
command result_t StdControl.init() {
return SUCCESS;
}
command result_t StdControl.start() {
return SUCCESS;
}
command void I1.increment() {
return count++;
}
command result_t StdControl.stop() {
return SUCCESS;
}
}
Component
Frame
Functions
provides
module
implementation
uses
Interface_A
Interface_B

Définition de nesc
21
Composant

Exemple D’application
22
Exemple D’application Blink
Le programme "Blink" se trouve à apps/Blink dans l'arbre deTinyOS. Cette
application allume la LED rouge à une fréquence de 1HZ.
L'application Blink est composée de deux composants: un module, appelé
"BlinkM.nc", et une configuration, appelée "Blink.nc". Blink.nc est utilisée pour
relier le module BlinkM.nc à d'autres composants requis par l'application Blink.

Définition de nesc
23

Définition de nesc
24
 La commande init() initialise simplement le
composant Leds en appelant Leds.init()
 La commande start() invoqueTimer.start()
pour créer leTimer répétitif (REPEAT
TIMER) qui expire à chaque 1000 ms
 stop() arrête leTimer
 A chaque fois que l'événementTimer.fired()
est signalé, la commande Leds.redToggle()
permet d'allumer la diode rouge

Définition de nesc
25

Compiler et exécuter une application nesC
26
La première étape de ce processus consiste à compiler les fichiers nécessaires à l'application et au
système d'exploitation. Celle-ci est réalisée via le compilateur NesC fourni par TinyOS. Son rôle est
premièrement de transformer les fichiers NesC en fichier C et deuxièmement d'y intégrer les fichiers
du noyau de TinyOS. Ce qui permet d'obtenir un fichier source C unique. Une fois cette étape
accomplie, il ne reste alors qu'à utiliser un compilateur C traditionnel qui va utiliser le fichier
précédemment créé afin de générer une application exécutable. Celle-ci sera donc constituée par la
«fusion» du système d'exploitation et du code applicatif.

Tiny os

Contenu connexe

Tendances

Similaire à Tiny os

Plus de MOHAMED ZARBOUBI

Dernier

Tiny os

Notes de l'éditeur