TP F2R101D Contiki

L'objectif de ce TP est de découvrir le système d'exploitation Contiki à travers plusieurs expérimentations.

Environnement

Le système Contiki est destiné à être exécuté sur des plateformes comme le Tmote Sky. Comme nous n'avons qu'un nombre limité de telles plateforme, nous utiliserons un environnement permettant d'émuler plusieurs motes et d'y exécuter le système Contiki.

Cette environnement, appelé Cooja, est disponible à travers la machine virtuelle Instant Contiki.

Démarrer la machine virtuelle Instant Contiki. Se logguer avec le mot de passe user

Démarrer l'environnement d'émulation Cooja et créer une nouvelle simulation

L'environnement présente différentes fenêtres dont :

• Network : fenêtre représentant les différents motes et leur positionnement
• Simulation Control : fenêtre permettant de contrôler le déroulement de la simulation
• Mote output : fenêtre permettant de récupérer les logs des motes

Session 1

Premier programme : Hello World

L'objectif de ce premier programme est d'appréhender l'environnement et de comprendre la structure d'un programme Contiki.

Ouvrir un éditeur de fichier (Menu Ubuntu de la VM : Applications/Accessories/Text Editor

Ouvrir le fichier ~/contiki/examples/hello-world/hello-world.c

Quelles sont les macros nécessaires à un programme minimal Contiki

A quelle librairie supplémentaire ce programme fait appel, et dans quel but ?

Pour compiler ce premier exemple, il faut d'abord créer un mote dans l'environnement que nous chargerons avec le firmware de ce programme.

Créer un mote dans l'environnement Cooja à partir du menu Motes/Add motes. Choisissez le type Sky mote

Dans la fenêtre de dialogue, indiquer le chemin vers le fichier hello-world.c

Lancer la compilation du programme par le bouton Compile

A quoi correspondent les nombreux fichiers C compilés avec votre programme ? Pourquoi sont-ils compilés ?

Créer le mote une fois la compilation terminée

Une fois le mote positionné dans la fenêtre Network, vous pouvez démarrer la simulation à partir de la fenêtre Simulation Control et observez le résultat dans la fenêtre Mote Output.

A quoi correspondent les premières lignes affichées ?

Précision d'un timer sous Linux

Cette expérimentation vise à montrer la relativité des timers sous Linux et de l'impact de l'architecture du système dans le traitement des interruptions.

Ouvrez l'éditeur de fichier dans la Machine Virtuelle Applications/Accessories/Text Editor

Saisissez le programme suivant et nommez le usleep_test.c :

#include <stdio.h>                                                    
#include <sys/time.h>                                                 
                                                                      
#define SIZE_WINDOW 100                                               
                                                                      
unsigned int usecs = 20000;                                           
struct timeval start, end, diff;                                      
double elapsed;                                                       
int t;                                                                
int mean_t;                                                           
int last_t[SIZE_WINDOW];                                              
int counter = 0;                                                      
int ready_to_print = 0;                                               
                                                                      
void main() {                                                         
      while (1) {                                                    
              gettimeofday(&start, 0);                               
              usleep(usecs);                                         
              gettimeofday(&end, 0);                                 
              timersub(&end, &start, &diff);                         
              t = diff.tv_usec;                                      
              last_t[counter++] = t;                                 
              counter %= SIZE_WINDOW;                                
              ready_to_print = (counter == SIZE_WINDOW - 1);         
              if (ready_to_print)                                    
              {                                                      
                   mean_t = 0;                                       
                   for (int i = 0; i < SIZE_WINDOW; ++i)             
                   {                                                 
                       mean_t += last_t[i];                          
                   }                                                 
                   mean_t /= SIZE_WINDOW;                            
                   printf("%d us\n", mean_t);                        
              }                                                      
      }
 }

En vous aidant des pages man, donnez le sens des appels système gettimeofday et usleep.

Quelle est la finalité de ce programme ?

Sauvegardez et compiler ce programme depuis un terminal, puis executez le.

$ gcc -std=c99 -D_BSD_SOURCE -o usleep_test usleep_test.c
$ ./usleep_test

Que constatez vous ? Expliquez le.

Nous allons observer l'influence de la charge du système sur le réveil de ce programme.

Tout en laissant le programme s'exécuter, lancer la commande suivante dans un autre terminal

$ cat /dev/zero | gzip - > /dev/null

Cette commande a pour effet d'occuper le temps CPU au maximum. Vous pouvez vérifier en observant la valeur de la charge par la commande top.

Que constatez vous pour le programme usleep ? Expliquez le.

Second programme : Faire clignoter une LED avec Contiki

L'objectif de ce programme est de réaliser un clignotement de la LED du mote toutes les secondes.

Reprenez la fenêtre d'édition de hello-world.c et sauvegardez le fichier dans blink.c

Dans un premier temps, il s'agit de créer, comme dans le programme précédent, une boucle qui va se mettre en pause toutes les secondes. Sous Linux, le réveil se fait de manière implicite par la sortie de la fonction usleep. Sous Contiki, le réveil s'effectue par la réception d'un événement signalant qu'un timer est arrivé à expiration.

La librairie des timers de Contiki est décrite sur cette page. Le code d'exemple d'utilisation d'un timer est le suivant :

PROCESS_THREAD(example_process, ev, data)
{
  static struct etimer et;
  PROCESS_BEGIN();

  /* Delay 1 second */
  etimer_set(&et, CLOCK_SECOND);

  while(1) {
    PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
    etimer_reset(&et);
    /* ... */
  }
  PROCESS_END();
}

Quels sont les lignes correspondant à la gestion du timer et quelle est leur utilité ?

Modifiez le programme pour qu'il affiche le texte Hello World toutes les secondes. Créez un nouveau mote dans le simulateur pour valider votre programme

L'interface d'accès au LEDs du mote est décrite sur cette page.

Modifiez votre programme pour réaliser le clignotement de la LED

Pensez à inclure l'entête pour la définition des fonctions d'accès aux LEDs

#include "dev/leds.h"

Pensez à modifier le Makefile pour la compilation

CONTIKI_PROJECT = hello_world blink

Créer un nouveau mote pour compiler votre programme et exécutez le dans le simulateur Vous pouvez consulter l'état des LEDs des motes dans le simulateur à partir du menu Tools/Mote Interface Viewer puis en sélectionnant Sky LEDs dans la liste déroulante.

Pour aller plus loin

Il est possible d'effectuer la même mesure du temps de réveil que dans le programme sous Linux en utilisant l'appel système clock_time décrit sur cette page. L'appel retourne un nombre (unsigned int) de TICK depuis le début de l'exécution du firmware.

Modifiez le programme pour afficher le nombre de TICK utilisés jusqu'à l'expiration du timer.

Sachant qu'il y a 128 TICK par seconde, le nombre retourné correspond-t'il à ce qui est attendu ?