Changes between Version 26 and Version 27 of IOC_T06


Ignore:
Timestamp:
Mar 20, 2026, 5:37:08 AM (7 months ago)
Author:
franck
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • IOC_T06

    v26 v27  
    115115
    116116Chaque tâche est représentée par
    117 - une fonction `step_Tache()` qui code son comportement qui sera appelée dans la fonction `loop()`.
    118 - une seconde fonction `init_Tache()` qui initialise les ressources de la tâche (périphériques) et l'état interne.
    119 - une structure contenant l'état interne et le contexte d'exécution représenté par une variable globale sous forme d'une structure `Tache_t`. Cette structure est passée en argument de la tâche des fonctions `init_Tache()` et `step_Tache()`.
    120 
    121 Les fonctions `step_Tache()` et `init_Tache()` peuvent avoir des variables locales mais leur état n'est pas conservé entre deux instances d'exécutions.
    122 Elles peuvent aussi avoir des variables static mais ces variables ont une valeur unique même si la tâche est en plusieurs exemplaires et que donc elle utilise la même fonction `step_Tache()`. Les variables static ne sont pas conseillées parce qu'elles ne peuvent être initialisées dans la fonction `init_Tache()`. Expliquez pourquoi dans le CR pour vérifier que vous avez compris.
     117- une fonction `step_tache()` qui code son comportement qui sera appelée dans la fonction Arduino `loop()`.
     118- une seconde fonction `init_tache()` qui initialise les ressources de la tâche (périphériques) et l'état interne qui sera appelée par la fonction Arduino `setup()`.
     119- une structure contenant l'état interne et le contexte d'exécution représenté par une variable globale sous forme d'une structure `ctx_tache_t`. Cette structure est passée en argument de la tâche des fonctions `init_tache()` et `step_tache()`.
     120
     121Les fonctions `step_tache()` et `init_tache()` peuvent avoir des variables locales mais leur état n'est pas conservé entre deux instances d'exécutions.
     122Elles peuvent aussi avoir des variables static mais ces variables ont une valeur unique même si la tâche est en plusieurs exemplaires et que donc elle utilise la même fonction `step_tache()`. Les variables static ne sont pas conseillées parce qu'elles ne peuvent être initialisées dans la fonction `init_tache()`. Expliquez pourquoi dans le CR pour vérifier que vous avez compris.
    123123
    124124La structure contexte ressemble à :
    125125{{{#!c
    126 struct Tache_s {
     126typedef struct {
    127127  unsigned int etat; 
    128128  int config;       
    129 };
    130 struct Tache_s T1, T2;  // 2 contextes pour 2 instances de tâches ayant le même comportement
    131 }}}
    132 
    133 
    134 C'est la fonction `init_Tache()`qui initialise le contexte avec des paramètres.
    135 {{{#!c
    136 void init_Tache(struct Tache_s *ctx, params...) {
     129} ctx_tache_t;
     130
     131ctx_tache_t T1, T2;  // 2 contextes pour 2 instances de tâches ayant le même comportement
     132}}}
     133
     134
     135C'est la fonction `init_tache()`qui initialise le contexte avec des paramètres.
     136{{{#!c
     137void init_tache(ctx_tache_t *ctx, params...) {
    137138   // Initialisation du contexte}
    138139   ctx->etat = etat_initial;  //  reçu dans les paramètres
    … …  
    141142}}}
    142143
    143 La fonction `loop()` demande donc l'exécution des fonctions `step_Tache()` à tour de rôle.
     144La fonction Arduino `loop()` demande donc l'exécution des fonctions `step_tache()` à tour de rôle.
    144145Les tâches n'ont pas le droit de conserver le processeur, sinon cela crée un blocage du système (une famine pour les autres tâches).
    145146Cela signifie qu'il est interdit de faire des boucles d'attente d'un événement.
    146147
    147 `connectors` sont des pointeurs vers des variables globales utilisées pour la communications inter-tâches.
     148`connectors` sont des pointeurs vers des variables globales utilisées pour la communication inter-tâches.
    148149La structure générale d'une tâche est la suivante :
    149150
    150151{{{#!c
    151 void step_Tache(tache_t *ctx, connectors....) {   
     152void step_tache(ctx_tache_t *ctx, connectors....) {   
    152153   // test de la condition d'exécution, si absent on SORT
    153154   if (evement_attendu_absent) return;
    … …  
    205206//--------- définition de la tache Led
    206207
    207 struct Led_s {
    208   int timer;                                              // numéro du timer pour cette tâche utilisé par WaitFor
     208typedef struct {
     209  int timer;                                              // n° du timer pour cette tâche utilisé par WaitFor
    209210  unsigned long period;                                   // periode de clignotement
    210211  int pin;                                                // numéro de la broche sur laquelle est la LED
    211212  int etat;                                               // etat interne de la led
    212 };
    213 
    214 void init_Led( struct Led_s * ctx, int timer, unsigned long period, byte pin) {
     213} ctx_led_t;
     214
     215void init_led(ctx_led_t * ctx, int timer, unsigned long period, byte pin) {
    215216  ctx->timer = timer;
    216217  ctx->period = period;
    … …  
    221222}
    222223
    223 void step_Led( struct Led_s * ctx) {
     224void step_led(ctx_Led_t * ctx) {
    224225  if (!waitFor(ctx->timer, ctx->period)) return;          // sort s'il y a moins d'une période écoulée
    225226  digitalWrite(ctx->pin,ctx->etat);                       // ecriture
    … …  
    229230//--------- definition de la tache Mess
    230231
    231 struct Mess_s {
     232struct {
    232233  int timer;                                              // numéro de timer utilisé par WaitFor
    233234  unsigned long period;                                   // periode d'affichage
    234235  char mess[20];
    235 } ;
    236 
    237 void init_Mess( struct Mess_s * ctx, int timer, unsigned long period, const char * mess) {
     236} ctx_mess_t;
     237
     238void init_mess(ctx_mess_t * ctx, int timer, unsigned long period, const char * mess) {
    238239  ctx->timer = timer;
    239240  ctx->period = period;
    … …  
    242243}
    243244
    244 void step_Mess(struct Mess_s *ctx) {
     245void step_mess(ctx_mess_t *ctx) {
    245246  if (!(waitFor(ctx->timer,ctx->period))) return;         // sort s'il y a moins d'une période écoulée
    246247  Serial.println(ctx->mess);                              // affichage du message
    … …  
    249250//--------- Déclaration des contexte de tâches
    250251
    251 struct Led_s Led1;
    252 struct Mess_s Mess1;
     252ctx_led_t Led1;
     253ctx_mess_t Mess1;
    253254
    254255//--------- Setup et Loop
    255256
    256257void setup() {
    257   init_Led(&Led1, 0, 100000, LED_BUILTIN);               // Led est exécutée toutes les 100ms
    258   init_Mess(&Mess1, 1, 1000000, "bonjour");              // Mess est exécutée toutes les secondes
     258  init_led(&Led1, 0, 100000, LED_BUILTIN);               // Led est exécutée toutes les 100ms
     259  init_mess(&Mess1, 1, 1000000, "bonjour");              // Mess est exécutée toutes les secondes
    259260}
    260261
    261262void loop() {
    262   step_Led(&Led1);                                       
    263   step_Mess(&Mess1);
    264 }
    265                                      
     263  step_led(&Led1);                                       
     264  step_mess(&Mess1);
     265}                             
    266266}}}
    267267
    … …  
    320320enum {EMPTY, FULL};
    321321
    322 struct mailbox_s {
     322struct {
    323323  int state;
    324324  int val;
    325 };
    326 
    327 struct mailbox_s mb = {.state = EMPTY};
     325} mailbox_t ;
     326
     327mailbox_t mb = {.state = EMPTY};
    328328
    329329void step_T1(... mailbox_t * mb ...) {
    … …  
    356356Ici, il faut créer une fonction `SerialEvent()` qui sera invoqué lors de la réception d'un caractère par le port série.
    357357
    358 Dans ce système, la fonction ISR sera comme une fonction step_Tache.
     358Dans ce système, la fonction ISR sera comme une fonction step_tache.
    359359
    360360**Question**