Protocole de routage "many-to-one" simple
Dans cet atelier, vous allez développer votre premier protocole de routage pour RCSF. Vous allez aussi découvrir comment créer une application TinyOS à partir de composants. Puis exécuter l'application dans TOSSIM, et analyser les résultats obtenus.
L'objectf de ce protocole est de créer un arbre qui couvre le maximum de capteurs, dont la racine se situe au puis (sink node).
Nous appellerons ce protocole HTC pour (Hierarchical Tree Construction).
Le nœud puis lance la procédure de création de l'arbre en envoyant par "broadcast" une requête de création.
Quand un noeud reçois cette requête il considère l'émetteur de la requête comme son père et le mémorise dans une variable locale ParentID.
Donc le message de requête va contenir au moins l'identifiant de l'émetteur de la requête.
Voici le fichier le fichier HTC.h définissant la structure du message de requête et son identifiant :
#ifndef HTC_MESSAGES_H
#define HTC_MESSAGES_H
#define SINK_NODE 0
typedef struct TreeReqMsg {
uint16_t src; // This is the node ID
}TreeReqMsg;
enum { AM_TREQMSG = 50 // This is the packet ID of control messages (Tree Request Messages) that are sent to build the tree };
#endif
Comme expliqué ci-dessus, cette première version du protocole aura besoin d'envoyer et recevoir des messages. Pour cela, nous utiliserons le composant GenericComm de TinyOS qui implémente les interfaces SendMsg et ReceiveMsg permettant d'envoyer et recevoir des messages respectivement.
Toute fois, afin d'implémenter le protocole lui même (initier la procédure de création de l'arbre par le puis, noter le noeud père, etc.) nous aurons besoin de développer notre propre composant qu'on appellera TreeBuilderM.nc. Ce composant utilisera les interfaces SendMsg et ReceiveMsg de GenericComm pour l'envoie et la réception des messages.
TreeBuilderM.nc implémente l'interface StdControl obligatoirement (imposé par TinyOS) pour son initialisation, son lancement et son arrêt.
Analysez le code suivant qui implémente le module TreeBuilder et répondez aux questions suivantes :
1/ Qui lance la construction de l'arbre ?
2/ A qui est envoyée la requête de construction de l'arbre ? qui va la recevoir ?
3/ Est ce que cette version du protocole permettra de réaliser une couverture maximale des noeuds du réseau ? Pourquoi ?
module TreeBuilderM {
provides { interface StdControl; }
uses { interface ReceiveMsg as ReceiveTreeReqMsg; interface SendMsg as SendTreeReqMsg; }
}
implementation {
//Routing
uint16_t parentId;
//Communication
TOS_Msg buffer; // Each node has a buffer where it stores received messages.
//Functions and tasks
task void sendInitTreeReq(); // This task is launched by the SINK_NODE to initialize tree construction task
//Implementation of StdControl Interface
command result_t StdControl.init() {
parentId = TOS_BCAST_ADDR; //Unknown parent
return SUCCESS;
}
command result_t StdControl.start() {
if (TOS_LOCAL_ADDRESS == SINK_NODE) {
post sendInitTreeReq(); //Starting the creation of the tree
}
return SUCCESS;
}
task void sendInitTreeReq() {
struct TreeReqMsg* ptr;
ptr = (struct TreeReqMsg*)(buffer.data);
ptr->src = TOS_LOCAL_ADDRESS; // I will be a parent
call SendTreeReqMsg.send(TOS_BCAST_ADDR,sizeof(struct TreeReqMsg),&buffer);
}
command result_t StdControl.stop() {
return SUCCESS;
}
event result_t SendTreeReqMsg.sendDone(TOS_MsgPtr pmsg, result_t success ) {
return SUCCESS;
}
event TOS_MsgPtr ReceiveTreeReqMsg.receive(TOS_MsgPtr pmsg) {
struct TreeReqMsg * ptr;
ptr = (struct TreeReqMsg *)(pmsg->data);
parentId = ptr->src; // I received a tree construction request. I note the Id of my parent
dbg(DBG_USR2,"__ROUTE__:parent=%d\n",parentId);
return pmsg;
}
}
Pour construire l'application HTC.nc il faut maintenant relier les différents composants qui constituent cette application.
Analysez le code suivant :
includes HTC;
configuration HTC { }
implementation {
components Main, GenericComm, TreeBuilderM;
Main.StdControl -> TreeBuilderM;
Main.StdControl -> GenericComm.Control;
//Tree Builder
TreeBuilderM.ReceiveTreeReqMsg -> GenericComm.ReceiveMsg[AM_TREQMSG];
TreeBuilderM.SendTreeReqMsg -> GenericComm.SendMsg[AM_TREQMSG];
}
Avant de compiler et exécuter l'application HTC, nous devons d'abord définir la topologie du réseau. Pour simplifier les choses, nous choisirons d'utiliser une grille de 7x7 noeuds.
Le fichier suivant définie une telle topologie :
Pour compiler l'application pour être émulé par TOSSIM, tapez
make pc
Pour lancer l'exécution, tapez :
export DBG=usr2
./build/pc/main.exe -t=10 -r=lossy -rf=./grid7x7 49
Analysez le résultat obtenu et répondre aux questions suivantes :
1/ Combien de noeuds sont couverts par l'arbre construit ?
2/ Qu'elle est la particularité des noeuds couverts par l'arbre ?
3/ Que proposez vous pour améliorer la couverture du protocole ?
