Tâches Page 1 of 10

Tâches

TÂCHES

5.1. DÉFINITION

Une tâche est un programme en cours d'exécution. Plusieurs tâches peuvent s'exécuter dans une même
application, et c'est habituellement le cas.
Dans une application, on trouvera typiquement une tâche pour les déplacements du bras, une tâche automate,
une tâche pour l'interface utilisateur, une tâche pour le suivi des signaux de sécurité, des tâches de
communication...
Une tâche est caractérisée par les éléments suivants :
• un nom : un identifiant de tâche unique à l'intérieur de la librairie ou de l'application
• une priorité ou une période : paramètre pour le séquencement des tâches
• un programme : le point d'entrée (et de sortie) de la tâche
• un état : actif ou arrêté
• la prochaine instruction à exécuter (et son contexte)

5.2. REPRISE APRÈS UNE ERREUR D'EXÉCUTION

Quand une instruction provoque une erreur d'exécution, la tâche est interrompue. L'instruction taskStatus() sert
à diagnostiquer l'erreur d'exécution. Il est alors possible de redémarrer la tâche avec l'instruction taskResume().
Si l'erreur d'exécution peut être corrigée, la tâche peut reprendre à partir de la ligne d'instruction où elle s'est
arrêtée. Dans le cas contraire, il est nécessaire de repartir soit avant, soit après cette ligne d'instruction.

Démarrage et arrêt d'application

Lorsqu'une application est démarrée, son programme start() est exécuté dans une tâche du nom de l'application
suivi de ’~’, et de priorité 10.
Lorsqu'une application se termine, son programme stop() est exécuté dans une tâche du nom de l'application
précédé de ’~’, et de priorité 10.
Si l'arrêt d'une application est provoqué depuis l'interface utilisateur du contrôleur MCP, la tâche de démarrage,
si elle existe encore, est immédiatement détruite. Le programme stop() est exécuté ensuite, puis les tâches de
l'application éventuellement restantes sont supprimées dans l'ordre inverse de celui de leur création, après quoi
les librairies sont déchargées de la mémoire.

5.3. VISIBILITÉ

Une tâche n'est visible que de l'intérieur de l'application ou de la librairie qui l'a créée. Les instructions
taskSuspend(), taskResume(), taskKill() et taskStatus() agissent sur une tâche créée par une autre librairie
comme si la tâche n'existait pas. Deux librairies différentes peuvent donc créer des tâches ayant le même nom.

5.4. SÉQUENCEMENT

Lorsque qu'une application a plusieurs tâches en cours d'exécution, celles-ci semblent s'exécuter simultanément
et indépendamment. Ceci est vrai si l'on observe l'application globalement sur des intervalles de temps
suffisamment larges (de l'ordre de la seconde), mais n'est pas exact lorsque l'on s'intéresse au comportement
précis sur un intervalle de temps réduit.
En effet, le système n'ayant qu'un seul processeur, il ne peut exécuter qu'une seule tâche à la fois. La
simultanéité de l'exécution est simulée par un séquencement rapide des tâches, qui exécutent à tour de rôle
quelques instructions avant que le système ne passe à la tâche suivante.

Séquencement

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 2 of 10

Le séquencement des tâches est fait suivant les règles suivantes :

1. Les tâches sont séquencées suivant leur ordre de création
2. A chaque séquence, le système essaye d'exécuter un nombre de lignes d'instructions égal à la priorité de
la tâche.
3. Quand une ligne d'instruction ne peut pas être terminée (erreur d'exécution, attente d'un signal, tâche
arrêtée, etc.), le système passe à la tâche suivante.
4. Lorsque toutes les tâches sont terminées, le système conserve du temps disponible pour les tâches
système de priorité inférieure (par ex. communication réseau, rafraîchissement de l'écran utilisateur,
accès aux fichiers) avant de démarrer un nouveau cycle.
L'attente maximum entre deux cycles consécutifs est égale à la durée du dernier cycle de
séquencement ; mais le plus souvent, cette attente est nulle car le système n'en a pas besoin.

Les instructions pouvant provoquer le séquencement immédiat de la tâche suivante sont :

• watch() (attente temporisée d'une condition)
• delay() (temporisation)
• wait() (attente d'une condition)
• waitEndMove() (attente de l'arrêt du bras)
• open() et close() (attente de l'arrêt du bras, puis temporisation)
• taskResume() (attend que la tâche soit prête à être relancée)
• taskKill() (attend que la tâche soit effectivement tuée)
• disablePower() (attend que la puissance soit effectivement coupée)
• Les instructions accédant au contenu du disque (libLoad, libSave, libDelete, libList, setProfile)
• Les instructions de lecture/écriture de sio (opérateur =, sioGet(), sioSet())
• setMutex() (attend que le mutex booléen soit faux)

5.5. TÂCHES SYNCHRONES

La séquence décrite ci-dessus est la séquence des tâches normales, appelées tâches asynchrones, dont le
système programme l'exécution la plus rapide possible. Il est parfois nécessaire de programmer les tâches à
intervalles réguliers, que ce soit pour l'acquisition de données ou pour le contrôle de périphérique : on parle alors
de tâches synchrones.
Celles-ci sont exécutées dans le cycle de séquence en interrompant la tâche asynchrone en cours entre deux
lignes de . Lorsque les tâches synchrones sont terminées, la tâche asynchrone reprend.
Le séquencement des tâches synchrones obéit aux règles suivantes :
1. Chaque tâche synchrone est séquencée exactement une fois pour chaque période définie lors de la
création de la tâche (par exemple toutes les 4 ms).
2. Lors de chaque séquencement, le système exécute jusqu'à 3000 lignes d'instructions . Il passe à la tâche
suivante lorsqu'une ligne d'instructions ne peut être terminée immédiatement (erreur d'exécution, attente
d'un signal, tâche arrêtée, ...).
En pratique, une tâche synchrone se termine souvent explicitement par l'instruction delay(0) qui oblige le
système à passer au séquencement de la tâche suivante.
3. Les tâches synchrones de même période sont séquencées suivant leur ordre de création.

5.6. ERREUR DE CADENCE

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 3 of 10

Si la durée d'exécution d'une tâche synchrone est supérieure à la période définie, le cycle en cours se termine
normalement mais le cycle suivant est annulé. Cette erreur de cadence est signalée à l'application en mettant à
true la variable booléenne spécialement prévue à cet effet lors de la création de la tâche. Ainsi, cette variable
booléenne indique au début de chaque cycle si le séquencement précédent s'est exécuté entièrement ou non.

5.7. RAFRAÎCHISSEMENT DES ENTRÉES/SORTIES

Concernant l'actualisation des entrées/sorties, il existe 2 groupes de cartes :

• Groupe de cartes du système :
CpuIO, DsiIO, FastIO, PowerSupplyIO, Rsi9IO, StarcIO.
• Groupe de cartes utilisateur :
J206 (EtherCAT master), J207/J208 (Real Time Ethernet), Fieldbus (Hilscher CIFX50E-xx PCIe boards).
Le temps de cycle d'actualisation du groupe de cartes du système est défini par le temps de cycle du système.
Le temps de cycle d'actualisation du groupe de cartes utilisateur est, quant à lui, défini en sélectionnant un
multiple du temps de cycle du système.
L'actualisation du groupe de cartes utilisateur peut être configurée selon 2 modes différents :
• Mode par défaut.
• Mode sans gigue.
Description des figures de temporisation ci-dessous :
Nom de tâche Description
Cette tâche gère la trajectoire du robot et l'actualisation des cartes d'E/S du
Synchro task
système.
IO refresh task Cette tâche gère l'actualisation des cartes d'E/S.
VAL3 synchro Cette tâche gère les tâches synchrones (voir chapitre 5.5).
VAL3 asynchro Cette tâche gère les tâches (voir chapitre 5.1).

S : Signifie groupe de carte d'E/S du Système.

U : Signifie groupe de carte d'E/S Utilisateur.
M : Signifie processus de Mouvement, générateur de trajectoire.

: Montre la gigue d'exécution de la tâche.

5.7.1. ACTUALISATION DES CARTES UTILISATEUR MODE PAR DÉFAUT

La figure ci-dessous représente l'exécution des différentes tâches lorsque le ratio du cycle d'actualisation du
groupe de cartes utilisateur a la valeur 1.

Si le temps d'actualisation de la carte d'E/S utilisateur est trop long (en fonction du nombre d'E/S) un
dépassement de délai se produit pendant la tâche d'actualisation des E/S. Dans ce cas, le ratio d'actualisation
de la carte d'E/S utilisateur doit être augmenté.
La figure ci-dessous représente l'exécution des différentes tâches lorsque le ratio du cycle d'actualisation des
cartes utilisateur a la valeur 2.

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 4 of 10

Remarque :
• Les valeurs des E/S utilisateur peuvent changer au cours d'un cycle "VAL3 asynchro".
• Un dépassement de délai de la tâche "IO refresh task" n'interrompt pas le robot mais toutes les valeurs des
E/S utilisateur sont invalides. Le ratio d'actualisation des cartes utilisateur peut être modifié depuis le MCP et
n'exige aucun redémarrage.

5.7.2. ACTUALISATION DES CARTES UTILISATEUR MODE SANS GIGUE

Dans ce mode, la tâche d'actualisation des E/S utilisateur n'est pas abandonnée et les cartes utilisateur sont
actualisées dans le contexte de la tâche de synchronisation.
La figure ci-dessous représente l'exécution des différentes tâches lorsque le ratio du cycle d'actualisation du
groupe de cartes utilisateur a la valeur 1.

Si le temps d'actualisation de la carte utilisateur (U) est trop long (en fonction du nombre d'E/S) un dépassement
de délai de la "synchro task" se produit. Ce dépassement de délai est considéré comme une erreur, le robot est
arrêté et un redémarrage est nécessaire.
La figure ci-dessous représente l'exécution des différentes tâches lorsque le ratio du cycle d'actualisation du
groupe de cartes utilisateur a la valeur 2.

Il convient de remarquer que les valeurs des E/S utilisateur peuvent changer au cours d'un cycle
"VAL3 asynchro".

5.7.3. COMMENT SÉLECTIONNER LE MODE D'ACTUALISATION DES CARTES

UTILISATEUR ET DÉFINIR LE RATIO DU CYCLE
Le mode d'actualisation des cartes utilisateur et le ratio cyclique peuvent être modifiés dans le fichier
usr/configs/cell.cfx.
<UserIORefresh>
<string name = "mode" value = "MODE" />
<Float name = "cyclicRatio" value = "RATIO" />
</UserIORefresh>

Mode Ratio
default -1 : utiliser la valeur par défaut (valeur 1).
noJitter 1 à N : Ratio du temps de cycle du système (par défaut 4 ms).

Par exemple, avec le temps de cycle du système par défaut (4ms)

Ratio Ratio
1 4 ms

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 5 of 10

2 8 ms
3 12 ms
... ...

5.8. SYNCHRONISATION

Il est parfois nécessaire de synchroniser plusieurs tâches avant qu'elles ne poursuivent leur exécution.
Si l'on connaît a priori la durée d'exécution de chacune des tâches, cette synchronisation peut se faire par
simple attente d'un signal émis par la tâche la plus lente. Mais lorsqu'on ne sait pas quelle tâche sera la plus
lente, il faut utiliser un mécanisme de synchronisation plus complexe dont un exemple de programmation est
donné ci-dessous.
Exemple
// Synchronization program for N tasks
Le programme synchro(num& n, bool& bSynch, num nN) ci-après doit être appelé dans chaque tâche à
synchroniser.
La variable n doit être initialisée à 0, bSynch à false et nN au nombre de tâches à synchroniser.
begin
n = n + 1
// Task synchronization waiting instruction
// makes sure all tasks are waiting here to resume operation
wait((n==nN) or (bSynch==true))
bSynch = true
n = n - 1
// Task release waiting instruction
// makes sure all tasks have resumed operation to clear synch context
wait((n==0) or (bSynch == false))
bSynch = false
end

5.9. PARTAGE DE RESSOURCE

Quand plusieurs tâches utilisent le même système ou la même ressource de cellule (données globales, écran,
clavier, robot, etc.). il est important d'éviter tout conflit entre elles.
On peut pour cela utiliser un mécanisme d'exclusion mutuelle (’mutex’) qui protège une ressource en autorisant
son accès à une seule tâche à la fois. Un exemple de programmation de mutex en est donné ci-dessous.
Exemple
Cet affichage de programme (num c) remplit l'écran des mêmes caractères, en vérifiant qu'aucune autre tâche
n'écrit sur l'écran en même temps avec le même programme. bScreen doit être initialisé à false.
begin
// make sure only one task accesses the screen at one time
setMutex(bScreen)
c=c%10
// write something to the screen with chars
sOutput="Hello world"
// wait for screen refresh
delay(0.2)
// let other tasks access the screen now
bScreen=false
end

5.10. WATCHDOG

Le WatchDog est un moyen de sécuriser l'utilisation du robot. Il permet d'assurer que le robot ne peut être utilisé
que si une tâche est en cours.
Le système peut être configuré avec ou sans la fonction WatchDog. Quand le système est configuré avec la
fonction WatchDog, l'alimentation du robot ne peut être activée que si une application maintient le WatchDog
activé. Pour maintenir le WatchDog activé, la fonction wdgRefresh() dédiée doit être exécutée avant que le
délai du val3WatchdogPeriod ne soit écoulé.
Le WatchDog est configuré avec le paramètre WatchdogPeriod dans le fichier de configuration cell.cfx :

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 6 of 10

Le système démarre sans WatchDog. La valeur par défaut de

val3WatchdogPeriod<=0
val3WatchdogPeriod est -1 (sans WatchDog).
Le système démarre avec le WatchDog activé. L'alimentation
val3WatchdogPeriod>0 électrique du robot peut être activée uniquement après que le
(en second) WatchDog a démarré. Quand le WatchDog est activé, un message
est enregistré dans l'historique au démarrage du système.

La fonction wdgRefresh() de l'active :

bool wdgRefresh()
Fonction
Cette fonction démarre et actualise le WatchDog. Elle renvoie l'état actuel du WatchDog.
La fonction a démarré le WatchDog (premier appel de la fonction ou en cas de
false
dépassement du délai du WatchDog).
true Le WatchDog est activé et l'actualisation continue...

Lorsqu'un dépassement de délai du WatchDog a lieu, le robot effectue un arrêt cat 1 (EstopSoft). Le rappel de
la fonction wdgRefresh supprime immédiatement le Estop.
L'utilisation de la fonction wdgRefresh quand le système est configuré sans WatchDog génère une
Runtime Error 045. Dans ce cas, il n'est plus possible de mettre le robot sous tension (redémarrage
nécessaire).

5.11. INSTRUCTIONS

void taskSuspend(string sName)

Fonction
Cette instruction suspend l'exécution de la tâche sName.
Si la tâche est déjà dans l'état STOPPED, l'instruction est sans effet.
Une erreur d'exécution est générée si sName ne correspond à aucune tâche ou correspond à une tâche créée
par une autre librairie.
Voir aussi
void taskResume(string sName, num nSkip)
void taskKill(string sName)

void taskResume(string sName, num nSkip)

Fonction
Cette instruction reprend l'exécution de la tâche sName sur la ligne située à nSkip lignes d'instructions avant ou
après la ligne courante.
Si nSkip est négatif, l'exécution reprend avant la ligne courante. Si la tâche n'est pas dans l'état STOPPED,
l'instruction est sans effet.
Une erreur d'exécution est générée si sName ne correspond pas à une tâche , correspond à une tâche créée
par une autre librairie, ou s'il n'y a pas de ligne d'instruction à l'endroit du nSkip spécifié.

DANGER
Si la tâche suspendue commande des mouvements, il est conseillé d'utiliser nSkip = 1 pour assurer la
continuité de la trajectoire.

Voir aussi
void taskSuspend(string sName)
void taskKill(string sName)

void taskKill(string sName)

Fonction

Cette instruction suspend puis supprime la tâche sName. Après l'exécution de cette instruction, la tâche sName
n'est plus présente dans le système.
S'il n'existe pas de tâche sName ou si la tâche sName a été créée par une autre librairie, l'instruction n'a aucun

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 7 of 10

effet.
Voir aussi
void taskSuspend(string sName)
void taskCreate string sName, num nPriority, program(...)

void setMutex(bool& bMutex)

Fonction
Cette instruction attend que la variable bMutex soit false puis la règle à true.
Cette instruction est nécessaire pour utiliser une variable booléenne comme mécanisme d'exclusion mutuelle en
vue de la protection de ressources partagées (voir chapitre 5.9).

string help(num nErrorCode)

Fonction
Cette instruction renvoie la description du code d'erreur d'exécution spécifié avec le paramètre nErrorCode. La
description est donnée dans la langue actuelle du contrôleur.
Exemple
Ce programme vérifie s'il y a une erreur dans la tâche "robot" et affiche le code d'erreur pour l'opérateur s'il y en
a une.
nErrorCode=taskStatus("robot")
if (nErrorCode > 1)
sOutput=help(nErrorCode)
endIf

num taskStatus(string sName)

Fonction
Cette instruction renvoie le statut actuel de la tâche sName ou le code d'erreur de temps d'exécution de la tâche
si elle est en erreur :
Code Description
-1 Aucune tâche sName n'a été créée par la librairie ou l'application actuelle
La tâche sName est suspendue sans erreur d'exécution (instruction taskSuspend() ou mode de
0
débogage)
1 La tâche sName créée par la librairie ou l'application actuelle est en cours d'exécution
10 Calcul numérique non valide (division par zéro).
11 Calcul numérique non valide (par exemple ln(-1))
20 Accès à un tableau ayant un index supérieur à la taille du tableau.
21 Accès à un tableau ayant un index négatif.
25 Accès à une collection avec une clé non valable.
29 Nom de tâche invalide. Voir instruction taskCreate().
30 Le nom spécifié ne correspond à aucune tâche .
31 Une tâche de même nom existe déjà. Voir instruction taskCreate.
Seules 2 périodes différentes pour les tâches synchrones sont supportées. Modifier la période
32
d'éxécution.
40 Pas assez de place mémoire système.
41 Pas assez de mémoire d'exécution pour la tâche. Voir Taille de mémoire d'exécution.
60 Temps maximal d'exécution de l'instruction dépassé.
61 Erreur interne à l'interpréteur
70 Valeur de paramètre d'instruction invalide. Voir l'instruction correspondante.
80 Utilisation d'une donnée ou d'un programme d'une librairie non chargée en mémoire.
81 Cinématique incompatible : Utilisation d'une point/joint/config incompatible avec la cinématique du bras.
Le Frame ou Tool de référence d'une variable fait partie d'une librairie qui n'est pas accessible depuis
82
l'application (librairie non déclarée dans l'application de la variable ou variable avec attribut privée).
90 La tâche ne peut pas reprendre à l'endroit spécifié. Voir instruction taskResume().
100 La vitesse spécifiée dans le descripteur de mouvement est invalide (négative ou trop grande).
101 L'accélération spécifiée dans le descripteur de mouvement est invalide (négative ou trop grande).
La décélération spécifiée dans le descripteur de mouvement est invalide (négative, trop grande, ou
102
inférieure à la vélocité).
La vitesse de translation spécifiée dans le descripteur de mouvement est invalide (négative ou trop
103
grande).
104 La vitesse de rotation spécifiée dans le descripteur de mouvement est invalide (négative ou trop grande).
105 Le paramètre reach spécifié dans le descripteur de mouvement est invalide (négatif).
106 Le paramètre leave spécifié dans le descripteur de mouvement est invalide (négatif).
122 Tentative d'écriture sur une entrée du système.
123 Utilisation d'une entrée-sortie dio, aio ou sio non reliée à une entrée-sortie du système.
124 Tentative d'accès à une entrée-sortie protégée du système
125 Erreur de lecture ou d'écriture sur une dio, aio ou sio (erreur sur le bus de terrain)

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 8 of 10

Impossible d'exécuter cette instruction de mouvement : un mouvement demandé précédemment n'a pas
150
pu être exécuté (point hors d'atteinte, singularité, problème de configuration...)
153 Commande de mouvement non supportée
154 Instruction de mouvement invalide : cible hors de portée, ou vérifier le descripteur de mouvement.
160 Coordonnées de l'outil flange non valides
161 Coordonnées du repère world non valides
162 Utilisation d'un point sans repère de référence. Voir Définition.
163 Utilisation d'un repère sans repère de référence. Voir Définition.
164 Utilisation d'un outil sans outil de référence. Voir Définition.
165 Repère ou outil de référence invalide (variable globale liée à une variable locale)
250 Pas de licence d'exécution (runtime) pour cette instruction, ou validité de la licence démo dépassée.

Voir aussi
void taskResume(string sName, num nSkip)
void taskKill(string sName)

void taskCreate string sName, num nPriority, program(...)

Fonction
Cette instruction crée et lance la tâche sName.
sName doit contenir au moins 1 caractère choisi parmi "a..zA..Z0..9_". Aucune autre tâche créée par la même
librairie ne doit porter le même nom.
L'exécution de sName commence par l'appel de program avec les paramètres spécifiés. Il n'est pas possible
d'utiliser une variable locale pour un paramètre transmis par référence, afin d'assurer que la variable ne sera pas
effacée avant la fin de la tâche.
La tâche se terminera par défaut avec la dernière ligne d'instructions de program, ou plus tôt si elle est détruite
explicitement.
nPriority doit être compris entre 1 et 100. A chaque séquencement de la tâche, le système exécutera un
nombre de ligne d'instructions égal à nPriority, ou moins si une instruction bloquante est rencontrée (voir le
chapitre Séquencement).
Une erreur d'exécution est générée si le système n'a pas assez de mémoire pour créer la tâche, si sName n'est
pas valide ou déjà utilisé dans la même librairie, ou si nPriority n'est pas valide.
Exemple
// start a new task to read a message
taskCreate "t1", 10, read(sMessage)
// waits for the end of task t1
wait(taskStatus("t1") == -1)
// Use the message
sOutput=sMessage

Voir aussi
void taskSuspend(string sName)
void taskKill(string sName)
num taskStatus(string sName)

void taskCreateSync string sName, num nPeriod, bool& bOverrun,

program(...)
Fonction
Cette instruction crée et lance une tâche synchrone.
L'exécution de la tâche commence par l'appel du programme spécifié avec les paramètres spécifiés. Il n'est pas
possible d'utiliser une variable locale pour un paramètre transmis par référence, afin d'assurer que la variable ne
sera pas effacée avant la fin de la tâche.
Une erreur d'exécution est générée si le système ne possède pas la mémoire nécessaire pour pouvoir créer la
tâche ou si un ou plusieurs paramètres ne sont pas valides.
Pour une présentation détaillée des tâches synchrones (voir chapitre 5.5).
Paramètres

string sName Nom de la tâche à créer. Doit contenir au moins 1 caractère choisi parmi
"_a..zA..Z0..9". Deux tâches appartenant à la même application ou librairie ne
peuvent porter le même nom.
num nPeriod Période d'exécution en secondes de la tâche à créer (s). La valeur spécifiée est
arrondie à un multiple de la période de l'horloge du système. N'importe quelle
période positive est prise en charge mais le système ne prend en charge que 2
périodes différentes de tâches synchrones à la fois. Par défaut, la période
d'horloge du système a la valeur 4 ms (0.004s).
bool& bOverrun Variable booléenne indiquant les erreurs de cadence. Seules les variables globales
sont supportées, afin de garantir que la variable ne sera pas supprimée avant la

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 9 of 10

tâche.
program Nom du programme à appeler lorsque la tâche est lancée, les paramètres
correspondants apparaissent entre parenthèses.

Exemple
// Create a supervisor task scheduled every 20 ms
taskCreateSync "supervisor", 0.02, bSupervisor, supervisor()

void wait(bool bCondition)

Fonction
Cette instruction met la tâche courante en attente jusqu'à ce que bCondition soit true.
La tâche reste RUNNING pendant la durée de l'attente. Si bCondition est true lors de la première évaluation,
l'exécution se poursuit immédiatement sur la même tâche (il n'y a pas séquencement de la tâche suivante).
Voir aussi
void delay(num nSeconds)
bool watch(bool bCondition, num nSeconds)

void delay(num nSeconds)

Fonction
Cette instruction met la tâche courante en attente pendant nSeconds.
La tâche reste RUNNING pendant la durée de l'attente. Si nSeconds est négative ou nulle, le système procède
immédiatement au séquencement de la tâche suivante.
Exemple
Ce programme fonctionne en boucle et veille à ne pas utiliser inutilement les ressources du CPU :
while bExit==false
sOutput=toString("", clock()* 10)
// let another task perform its operation immediately
delay(0)
endWhile

Voir aussi
num clock()
bool watch(bool bCondition, num nSeconds)

num clock()
Fonction
Cette instruction renvoie la valeur actuelle de l'horloge système interne, exprimée en secondes.
La précision de l'horloge interne du système est la milliseconde. Elle est initialisée à 0 lors du démarrage du
contrôleur, et n'a donc aucune relation avec l'heure calendaire.
Exemple
Pour calculer le délai d'exécution entre deux instructions, enregistrer la valeur d'horloge avant la première
instruction :
nStart=clock()

Après la dernière instruction, calculer le délai d'exécution avec :

nDelay = clock()-nStart

Voir aussi
void delay(num nSeconds)
bool watch(bool bCondition, num nSeconds)

bool watch(bool bCondition, num nSeconds)

Fonction
Cette instruction met la tâche courante en attente jusqu'à ce que bCondition soit true ou jusqu'à ce que
nSeconds secondes soient écoulées.
Renvoie true si l'attente se termine lors que bCondition est true, sinon false lorsque l'attente se termine parce
que le délai est écoulé.

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024
Tâches Page 10 of 10

La tâche reste RUNNING pendant la durée de l'attente. Si bCondition est true à la première évaluation, la
tâche est exécutée immédiatement ; dans le cas contraire, le système séquence les autres tâches (même si
nSeconds est inférieur ou égal à 0).
Exemple
Ce programme attend un signal et affiche un message d'erreur après 20 s.
if (watch (diSignal==true, 20)) == false
sOutput="Error: waiting for Signal"
wait(diSignal==true)
endIf

Voir aussi
void delay(num nSeconds)
void wait(bool bCondition)
num clock()

STÄUBLI
Hotlines: 33 4 50 65 61 52
www.staubli.com

mk:@MSITStore:C:\Users\pjean\AppData\Local\Temp\SRS_J1~1.CHM::/D280935-... 01/10/2024