Changes between Version 1 and Version 2 of SysCom19

Timestamp:

Oct 9, 2019, 5:20:36 AM (6 years ago)

Author:

franck

Comment:

SysCom19

@@ -35 +35 @@
 = Exécution ''multi-tâches''
 
-== Tâches standards 
-
-Il est possible de programmer des applications multi-tâches coopératives dans l'environnement Arduino sans pour autant disposer des services d'un OS. Le principe a été volontairement simplifié à l'extrême. Ici, toute l'application sera dans un seul fichier et nous n'allons pas utiliser la programmation objet pour ne pas complexifier, mais pour une application plus ambitieuse, ce serait souhaitable pour une meilleure maintenance.
-
-Une application est composée de plusieurs tâches. Chaque tâche peut être répliquée en plusieurs instances et chaque tâche est exécutée à tour de rôle en temps partagé.
-* Une ''instance de tâche'' est une des copies d'une tâche
+== Principe
+
+Il est possible de programmer des applications multi-tâches coopératives dans l'environnement Arduino sans pour autant disposer des services d'un OS. Le principe a été volontairement simplifié à l'extrême. Ici, toute l'application sera dans un seul fichier.
+Nous n'allons pas utiliser la programmation objet pour ne pas complexifier, mais ce serait possible pour une application plus ambitieuse pour une meilleure maintenance.
+
+Une application est composée de plusieurs tâches. Chaque tâche peut être répliquée plusieurs fois dans l'application et chaque réplica de tâche est exécutée à tour de rôle en temps partagé.
+Les (réplica de) tâches communiquent entre elles par l'intermédiaire de variables globales.
+
+Les ISR (Interrupt Service Routine) qui sont des fonctions exécutées lors de la survenue d'interruption sont considérée comme des tâches.
+
+== Tâches 
 
 Chaque tâche est représentée par 
 * une fonction `loop_Tache()` qui code son comportement qui sera appelée dans la fonction `loop()`.
+  Dans cet exemple l'application a trois tâches : la tâche 1 est répliquée 2 fois et la tâche 2 n'a 
   {{{#!c
   loop() {
-    loop_tache1(args...); 
-    loop_tache1(args...);
-    loop_tache2(args...);
+    loop_tache1(args...); // 1er réplica de la tâche 1
+    loop_tache1(args...); // 2nd réplica de la tache 1 
+    loop_tache2(args...); // unique réplica de la tâche 2
   }
   }}}
-* une seconde fonction `setup_Tache()` qui initialise les ressources de la tâche (périphériques) et l'état interne. 
-
-Chaque tâche dispose de trois types de variables internes 
+  La fonction `loop()` demande donc l'exécution des fonctions `loop_Tache()` à tour de rôle.
+  Les tâches n'ont pas le droit de conserver le processeur sinon cela crée un blocage du système.
+  Cela signifie qu'il est interdit de faire des boucles d'attente d'un événement.
+  
+  La fonction loop() est en fait un ordonnanceur de tâche suivant un algorithme FIFO statique.
+
+  La fonction loop() ignore si la tâche est en mesure d'avancer. Les tâches sont toujours "prêtes". 
+  C'est chaque tâche qui doit vérifier si elle peut avancer, par exemple si les données
+  attendues sont disponible ou si assez de temps c'est écoulé depuis la dernière instance d'exécution. 
+  Si oui elle avance, sinon elle sort immédiatement et la tâche suivante dans la liste est exécutée.
+
+* une seconde fonction `setup_Tache()` qui initialise les ressources matérielles assignées de la tâche (périphériques) et l'état interne (voir plus loin).
+  {{{#!c
+  setup() {
+    setup_tache1(args...); // setup du 1er réplica de la tâche 1
+    setup_tache1(args...); // setup du 2nd réplica de la tache 1 
+    setup_tache2(args...); // setup de l'unique réplica de la tâche 2
+  }
+  }}}
+
+Chaque tâche (sous-entendu réplica de tâche) dispose de trois types de variables internes 
 * Variables locales temporaires :[[BR]]
   - Les fonctions `loop_Tache` et `setup_Tache` peuvent avoir des variables locales. 
-    L'état n'est pas conservé entre deux instances d'exécution.
+    L'état n'est pas conservé entre deux instances d'exécution de la tâche.
 * Variables d'état de tâche : [[BR]]
   - Elles peuvent aussi avoir des variables `static`. Ces variables ont une valeur 
-    unique pour toutes les instances de tâche.
+    unique pour toutes les réplicas d'une tâche.
 * Variables de contexte d'exécution :
-  - Enfin chaque instance de tâche dispose d'une structure contenant son état interne 
-    qui est conservé entre deux instance d'exécution. 
+  - Enfin chaque réplica de tâche dispose d'une structure contenant son état interne,
+    lequel est conservé entre deux instance d'exécution de la tâche. 
     Le contexte d'exécution représenté par une variable globale du programme sous forme d'une structure. 
-    Cette structure est passée en argument de la tâche des fonctions `setup_Tache()` et `loop_Tache`. 
+    Une structure différente est passée en argument de chaque réplica de tâche dans les arguments 
+    des fonctions `setup_Tache()` et `loop_Tache`. 
   - La structure contexte ressemble à :
     {{{#!c
@@ -71 +96 @@
       int config;        
     }; 
-    struct Tache_st T1, T2;  // deux contextes pour deux tâches.
+    struct Tache_st T1, T2;  // deux contextes pour deux réplicas d'une tâche.
     }}}
 
@@ -83 +108 @@
 }}}
 
-La fonction `loop()` demande donc l'exécution des fonctions `loop_Tache()` à tour de rôle.
-Les tâches n'ont pas le droit de conserver le processeur sinon cela crée un blocage du système.
-Cela signifie qu'il est interdit de faire des boucles d'attente d'un événement.
-`connectors` sont des pointeurs vers des variables globales utilisées pour la communications inter-tâches.
-La structure générale d'une tâche est la suivante :
-
+== Communication entre tâches
+
+Les tâches communiquent entre elles par des variables globales de l'application.
+Chaque tâche reçoit en argument les pointeurs vers les variables qu'elle utilise pour communiquer.
+Ces pointeurs sont nommés connecteurs (ou ports). 
+
+La structure forme de la fonction loop d'une tâche est donc :
 {{{#!c
 void loop_Tache(struct Tache_st *ctx, connectors....) {