TUTORIAL WORKBENCH 3.

© [Link] 2013 1
Introduction
Wind River General Plateform est un ensemble d’outils développés par WindRiver. Il permet la
définition et la mise au point d'applications temps-réel en se basant sur une gestion de projet
comme beaucoup d'outil de conception à l’heure actuelle. Le développement d'applications
temps-réel à partir de cet outil nécessite typiquement 2 ordinateurs reliés par une liaison série
ou Ethernet. L'ordinateur host (un PC ici) sert de support au développment de l'application et
fournit les outils liés à ce développement (éditeurs graphiques, cross-compilateurs, …).
L'ordinateur target représente le support d'exécution (la carte ARM7 utilisée pour la mise en
œuvre des microprocesseurs par exemple). On notera que cet ordinateur pourrait également être
un autre PC "booté" à partir de VxWorks au lieu de Windows. L'ordinateur host dispose
égaleme,t d'un simulateur du comportement de la cible permettant minimiser les intéractions
avec la cible. Cette option sera privilégiée au cours des manipulations à venir.

Création du projet

Configuration du projet

Développement de
l’application

Développement de
l’application

Test et déboggage de
l’application

Figure 1: Flot de developpement d'un projet

Parmi les différents outils, Workbench3.2 propose un environnement de développement intégré
(IDE) permettant la création du logiciel embarqué pour les systemes Wind River Linux ou
VxWroks. Workbench intègre la possibilité d’analyser le code (espace mémoire, performances,
etc) et autorise la gestion simultanée de plusieurs cibles. Un débuggeur permet également de
gérer plusieurs processus ou threads sur un cible isolée ou sur des cibles multiples. La Figure 1
montre le flot de développement typique d’un projet sous workbench.

© [Link] 2013 2
I Démarrage de Workbench3.3

A partir du menu Démarrer de Windows, ou en utilisant le raccourci présent sur le bureau,

procédez au lancement de Workbench3.3. Une fenêtrre de dialogue (cf Figure 2), vous
demande à chaque session de sélectionnez le repertoire de travail dans lequel seront stockés les
différents fichiers de vos projets :

 Informations sur l’ensemble des projets, dont les noms des projets, la liste des fichiers pour
chaque projet et la sspécification de construction du projet.
 Informations sur la session courante dont les types et positions des fenetres du workbench quand
vous quittez une session, les projets et les points d’arret courants.

Vous pouvez à votre convenance laisser le répertoire par défaut ou le modifier. Si vous choissez
cette dernière option, attention à ce que le chemin menant au repertoire ne contienne pas
d’espace dans les noms. Vous pouvez éventuellement cliquer sur la case permettant de valider
ce choix pour l’ensemble des sessions à venir.

Figure 2: sélection d'un espace de travail

Cliquez sur ok. Une nouvelle fenêtre fait son apparition, fenêtre qui va vous permettre la gestion
de votre projet.
Outline
Project explorer Editor and getting started resource

Remote System Build console and problems

Figure 3: Pont de vue pour le développement d’applications

© [Link] 2013 3
Comme Cofluent studio, Wind River Workbench est construit à partir d’une plateforme Eclipse,
standard industriel fournissant un cadre pour le développement de suites d’outils centrées
autour de l’organisation d’un projet. Un projet est vu comme un container rassemblant les
fichiers sources et répertoires. Le Workbench vous permet de visualiser l’organisation des
projets et reflète leurs dépendances et l’ordre dans lequel ils seront compilés et liés. La fenêtre
Workbench affiche ainsi les points de vue (perspectives), les vues et différents éditeurs qui vous
permettront de visualiser, manipuler et éditer les composantes de votre projet. Une perspective
est une mise en page d’éditeurs et de vues adaptées à une tâche particulière. Elle contrôle le
format des menus et des barres d’outil. Dans le cadre de l’enseignement proposé, nous
utiliserons les perspectives par défaut proposées par l’outil et prêtes à l’emploi (Figure 3).
Cette perspective propose les vues suivantes :

■ Project Explorer
■ Editor and Getting Started Resources
■ Outline
■ Remote Systems
■ Build Console and Problems

Remarque: il est possible d’agrandir une des zones au besoin. Pour revenir à l’affichage
multifenêtre, il suffit de cliquer sur restaure sur la gauche de l’écran ou de sélectionner la
fenêtre que vous souhaitez voir réapparaitre au coté de la ou les fenêtres couramment affichées.

II Création/Ouverture d'un projet

2.1 Création d'un projet

La création d'un projet peut s'effectuer automatiquement lors du démarrage du Workbench dans
le cas d’un projet préalablement crée lors d’une session précédente. Si tel n’est pas le cas,
explicitement à partir du Menu FileNew Wind River Workbench project. Une fenêtre de
création de projet s'affiche sur le modèle de la Figure 4.

Figure 4: Selection de la cible

Si ce n’est pas le cas, sélectionnez la cible comme étant l’OS temps réel Vxworks 6.8. Cliquez
ensuite sur next. Une nouvelle fenêtre apparaît sur le modèle de la Figure 5. Sélectionnez pour
demander la création d’une image à charger et qui pourra être dynamiquement liée et exécutée
dans l’espace mémoire de l’OS précédemment sélectionné.

© [Link] 2013 4
 Figure 5: Sélection du type de projet
Cliquez à nouveau sur next. La fenêtre suivante (Figure 6) vous demande de déterminer le nom
et l’emplacement du projet. On nommera ce projet tutorial et l’emplacement sera maintnu par
défaut dans le worspace défini au démarrage.

Figure 6: Nom et emplacement du projet

Cliquez finalement sur finish pour terminer cette étape. Vous pouver alors observer l’inclusion
du projet dans la vue project explorer.

2.2 Ouverture d'un espace de travail

L'ouverture d'un espace de travail existant peut se faire, comme pour la création,
automatiquement au démarrage de Workbench. Si vous souhaitez charger un autre projet,
utilisez le menu import et sélectionnez existing workbench project. Remplissez alors les champs
du formulaire pour référencer l’emplacement du projet à ouvrir.

© [Link] 2013 5
III Création/Insertion d’un fichier dans un projet

Une fois le projet créé, vous pouvez spécifier le ou les fichiers sources de l’application. Pour
saisir le code de l'application du Tutorial, deux possibilités vous sont offertes:

Figure 7: Création et insertion d'un fichier dans le projet

1. Création d’un nouveau fichier par le menu FileNewFile, également accessible par
l’icône (2ème en partant de la gauche) de la barre d’outil. Une fenêtre s’affiche et vous
permet de préciser la nature du fichier (include, source, …). Il s’agira ici d’un fichier
nommé tutorial.c et dont le code vous est proposé en annexe de ce
[Link] le parent forlder et terminez en cliquant sur finish

2. Vous pouvez également procéder à la création du projet via votre éditeur de texte
préféré (emacs par exemple) et demander à l’inclure via le menu Fileimport. Dans la
fenêtre qui s’affiche, sélectionnez file system dans la catégorie general. Cliquez sur next.
Dans la fenetre qui s’affiche(fig 8 à droite), précisez l’emplacement du ou des fichiers
sources et le répertoire de destination. Clôturez en cliquant sur finish et notez l’inclusion
du(des) fichiers dans la zone project explorer. Pour visualiser le fichier, il suffira de double
cliquer sur le nom du fichier.

Figure 8: Inclusion de fichiers dans le projet

© [Link] 2013 6
IV Compilation du projet

Double cliquez sur tutial.c vous permet d’afficher le code source de l’application Pour obtenir
l’exécutable de votre projet, cliquez avec le bouton droit de la souris sur le nom du projet dans
le project explorer et sélectionner build project. Alternativement, cliquez sur le 6ème icône en
partant de la gauche de la barre d’outils. Une fenetre d’avertissement comme ci-dessous peut
apparaitre. Ignorer et cliquez sur continue.

Figure 9: fenetre d'avertissement à ignorer

Un fichier exécutable portant le nom du projet et d'extension .out est généré et pourra ensuite
être téléchargé sur la cible pour exécution. Il apparait dans binaries du project explorer (cf
Figure 10). La zone du bas (onglet build console) vous permet d’observer les éventuelles
erreurs de compilation. Il vous appartient bien entendu d’apporter d’éventuelles corrections
avant recompilation du projet. En cliquant sur un objet (variable ou fonction) de la zone outline,
l’outil vous positionne directement dans l’éditeur sur la référence.

Figure 10: Nouvel etat de développement de projet après le build.

On notera que, comme stipulé auparavant, l’édition de lien dans workbench est effectuée et
vérifiée au moment du téléchargement du code sur la cible. Des problèmes d'édition de
liens peuvent donc apparaître et nécessiter des corrections ultérieures.

V Exécution de l’application
© [Link] 2013 7
La cible réelle est simulée par l'outil VxSim avec lequel il faut généralement établir une
connexion. Pour cela, cliquez avec le bouton droit de la souris sur vxsim0 dans la zone remote
sysstem. Séléctionnez ensuite connect vxsim0. Dans la zone du bas (onglet target console), vous
pouvez vérifier l’établissement de la connexion grâce à l’apparition du signal d’invite d’un shell
de commande (-->). Cette fenêtre simule un écran qui pourrait être connecté à la cible. Toute
demande d’écriture sur le flot de sortie (ex : printf) effectuée par l’application est affichée dans
cette fenêtre. Cette fenêtre peut également servir de flot d’entrée (scanf, getchar,…) comme
nous le verrons par la suite.

Figure 11: Configuration du debbogueur

Pour exécuter l’application en mode debug, cliquez bouton droit sur [Link] dans le
repertoire binaries du project explorer et sélectionnez Debug VxWorks kernel task. Dans la
fenêtre qui s’affiche (cf Figure 11), tapez le point d’entrée start qui permet la création des
différentes tâches. Cliquez ensuite sur debug. La Figure 12 montre le nouvel état de Workbench
une fois le debuggeur lancé. Cliquez sur run step over pour effectuer les instructions pas à
pas (l’instruction prochainement executée est surlignée dans le code source). Vous pouvez alors
vérifier les affichages produits par l’execution successives de ces instructions dans la zone
target console. Pour stopper l’exécution de votre application, tapez stop dans la zone target
console.

Figure 12: Nouvel état après lancement du debuggeur

© [Link] 2013 8
 Figure 13: Résultats de l’émulation
Pour faciliter la mise au point, des points d’arrêt peuvent être positionnés. Pour cela, double
cliquez dans la goutière (en bleu) sur la ligne à laquelle vous souhaitez poser le point d’arret. Ce
point d’arret se matérialise dans la zone breakpoints à droite de l’écran. Cliquez ensuite sur
runresume pour atteindre le point d’arrêt. Comme le montre la Figure 14, vous pouvez
examiner la mémoire. En plaçant votre souris sur l’objet, vous obtenez l’adresse et la valeur
courante de cette objet. Vous pouvez également visualiser la valeur dans la zone de l’écran en
bas à droite.

Figure 14: Inspection de la mémoire

Reprenez les différentes étapes en mettant en commentaire les printf internes aux procédures à
l’exception des procédures start et stop. Compilez votre projet, réexecutez et contrôlez que les
affichages ont disparu de la target console. Pour lancer l’application en continu, cliquez sur
l’icône run (11ième en partant de la gauche). Alternativement, sélectionnez run vxworks kernel
par clic droit sur [Link].

Remarque : On notera qu’Il est fortement conseillé de déconnecter la cible (« rebooter ») entre
chaque exécution lorsque le projet est modifié. Pour obtenir la fin complète de la session
cliquez avec le bouton droit de la souris sur vxsim0 et sélectionnez disconnect vxsim0 dans la
zone remote system. Alternativement, tapez reboot dans la fenêtre shell..

© [Link] 2013 9
VI Instrumentation

Un outil d’analyse logique (timeline) permet, comme sous Cofluent, de tracer l’activité de
l’operating system et voir l’enchainement de ces activités dans le temps (timeline). Pour cela, il
vous faut lancer au préalable l’outil system viewer : dans la zone remote system, cliquez avec le
bouton droit de la souris et sélectionnez system viewer configuration. Une fenêtre (Figure 15)
de configuration apparaît pour sélectionner les informations à observer. Dans l’onglet event
loggin level, selectionnez additionnal instrumentation. Dans le menu principal, cliquez sur
system viewerstart loggin. Lancez votre application (clic droit sur [Link] puis run kernel
task), puis demandez son arrêt comme précédemment à l’aide des commandes start et stop dans
la fenêtre de commandes du shell. Demandez l’arrêt de l’instrumentation (system viewer stop
logging). Vous pouvez ensuite récupérer les résultats depuis la cible en cliquant sur upload Log.
L’outil vous propose de changer de perspective pour mieux analyser les résultats. Vous pouvez
accepter ou refuser à votre convenance.

Figure 15: Fenêtre de configuration de system viewer

Une fenêtre de résultats sur le modèle de celui de la Figure 16 fait alors son apparition. On
notera la ressemblance avec les timeline obtenus sous cofluent.
Définition de la région d’observation
Zoom Définition de la région d’observation
(données du timeline)
(partie supérieure du timeline)

Figure 16: Exemple de résultat obtenu par system viewer

© [Link] 2013 10
Définissez une zone d’observation sur la partie supérieure du timeline à l’aide de la souris et
cliquez sur l’icône zoom pour obtenir le centrage du timeline. Selectionnez ensuite une zone de
la fenêtre du timeline à observer. Pour cela, cliquez sur le graphe (bouton gauche de la souris)
pour faire apparaître un premier curseur délimitant le début de la zone que vous souhaitez
visualiser. Maintenez enfoncé le bouton puis relâchez en fin de zone à visualiser (un deuxième
curseur apparaît). Cliquez ensuite à nouveau sur l’icône zoom (voir Figure 16). Réitérez cette
opération à plusieurs reprises si nécessaire afin d’obtenir une fenêtre temporelle d’une centaine
de µs (telle que celle apparaissant en Figure 17).

Figure 17: Zoom sur un cycle de synchronisation

On notera que le type d’appel système associé au symbole s'affiche lorsque vous cliquez dessus.
On peut ainsi observer les semGive (drapeaux pleins) et semTake (drapeaux vides) successifs,
ainsi que le taskDelay (flêche bleue).

Annexe: Le code de l'application

/* inclusion des bibliotheques */
#include "vxWorks.h"
#include "stdio.h"
#include "semLib.h"
#include "taskLib.h"

#define STACK_SIZE 20000

/* declaration des semaphores */

SEM_ID h,eoc;
/* declaration des Tid des taches */
int tidHorl,tidcan,tidmemo;

/* declaration des variables partagees */

int vcan;

/* declaration du code de la tache horloge */

void codehorloge(void)
{
while(1)
{taskDelay(2);

© [Link] 2013 11
 printf("horloge reveillee\n");
semGive(h);
}
}

/* declaration du code de la tache conversion */

void codeCAN(void)
{int n; /* un compteur local */
int memech[20]={15,34,45,67,43,23,0};
n=0;
while(1)
{/* attente de l'evenement H */
semTake(h, WAIT_FOREVER);
printf("conversion activee\n");
vcan=memech[n];
n=(n+1) % 7;
semGive(eoc);
}
}

/* declaration du code de la tache de méorisation */

void codememo(void)
{
while(1)
{/* attente de l'evenement EOC */
semTake(eoc, WAIT_FOREVER);

printf("mémorisation de la valeur: %d\n",vcan);

}
}

/* procedure de demarrage de l'application */

int start()
{
/* creation des semaphores */
h=semBCreate(SEM_Q_FIFO,SEM_EMPTY);
eoc=semBCreate(SEM_Q_FIFO,SEM_EMPTY);

/* demarrage des taches */

printf("demarrage des taches");
tidHorl=taskSpawn("horloge",15,0,STACK_SIZE,(FUNCPTR)codehorloge,0,0,0,0,0,0,0,0,0,0);
tidcan= taskSpawn("CAN",20,0,STACK_SIZE, (FUNCPTR)codeCAN,0,0,0,0,0,0,0,0,0,0);
tidmemo=taskSpawn("memorisation",20,0,STACK_SIZE,
(FUNCPTR)codememo,0,0,0,0,0,0,0,0,0,0);
return(OK);
}

/* procedure d'arret de l'application */

void stop()
{printf("arret de l'application ");
/* destruction des taches */
taskDelete(tidcan);
taskDelete(tidmemo);
taskDelete(tidHorl);
/* destruction des semaphores */
semDelete(h);
semDelete(eoc);
}

© [Link] 2013 12