Programmation PIC en C et machine d'état ?

[invite1a47bfa2]

Bonjour,

je travail sur un projet utilisant la TCP/IP stack de microchip.

Afin de partager les ressources du PIC? toutes les fonctions sont codées sous la forme de machine d'état (Switch/case)

j'aimerais comprendre comment cela fonctionne exactement.

Considérons deux fonctions de type machine d'état :

void toto_fct(void)
 {
     static enum _totoState
     {
         toto1 = 0,
         toto2,
         toto3,
         toto4,
     } totoState = toto1;
 
     switch(totoState)
     {
         case toto1:
             // Create a socket for this server to listen and accept connections on
             if(...)
                 return;
             totoState = toto2
break;
 
         case toto2:
             //bind to a local port
             PORTB = 0x00;
            PORTC = 0xFF;
             if(....)
                 return;
             
             totoState = toto3;
       break;
          
       case toto3:
             if(..)
                 return;
             totoState = toto4;
       break;
          
       case toto4:
                ...
             break;
          
         default:
             return;
     }
     return;
 }

et

void titi_fct(void)
 {
     static enum _titiState
     {
         titi1 = 0,
         titi2,
         titi3,
         titi4 ,     
} titiState = titi1;
 
     switch(titiState)
     {
         case titi1:
             if(...)
                 return;
             titiState = titi2;
             break;
 
         case titi2:
             //bind to a local port
             PORTB = 0x00;
             PORTC = 0xFF;
             if(....)
                 return;
             
             titiState = titi3;
      break;
          
       case titi3:
             if(...)
                 return;
             titiState = titi4;
      break;
          
       case titi4:
                ...
             break;
          
         default:
             return;
     }
     return;
 }

Elles sont appelées par le main de la façon suivante :

…
     while(1)
     {
        toto_fct();
        titi_fct();
      }

je vois deux fonctionnements possibles:

1.
- on rentre dans la boucle while, et la fonction toto_fct est exécutée.
- admettons que la machine d'état avance jusqu'à toto3, ou le test if renvoie true, ce qui a pour conséquence d'exécuter return et de quitter la fonction.
- la fonction titi_fct() est donc exécutée à son tour. Elle atteint l'état titi2 avant d'être quittée..
- la boucle while est terminée, elle est donc réexecutée.
- la fonction toto_fct est reexecutée à partir de l'état toto3, et son État avance autant que possible avant d'être quittée.
- la fonction titi_fct est relancée à partir de titi2, et ainsi de suite...

OU

2.
- on rentre dans la boucle while, et la fonction toto_fct est exécutée.
- admettons que la machine d'état avance jusqu'à toto3, ou le test if renvoie true, ce qui a pour conséquence d'exécuter return et de quitter la fonction.
- la fonction titi_fct() est donc exécutée à son tour. Elle atteint l'état titi2 avant d'être quittée..
- la boucle while est terminée, elle est donc réexecutée.
- la fonction toto_fct est reexecutée à partir du début (initialisation des vars, état toto1, ....)...
- la fonction titi_fct est reexecutée à partir du début (initialisation des vars, etat titi1, ....)...

Laquelle de ces procédures est la bonne?

Merci de votre aide,

Alexandre
-----

[invite1a47bfa2]

juste pour remonter le sujet...

[Jack]

Vu que les variables qui mémorisent l'état des 2 machines sont déclarées "static", leur valeur n'est pas réinitilisée.

J'opte donc pour la solution 1.

A+