next topic »

[on:]

Bonjour à tous.

Mon système comporte un bouton poussoir câblé sur l'entrée d'interruption.
Une fois dans la routine d'interruption, en fonction de la routine dans laquelle mon système se trouve avant l'appel par le bouton, je dois appeler une autre routine, et ainsi de suite.
Le problème est que je ne sors jamais réellement de l'interruption car j'appelle mes routine à partir d'un "case".

Je n'ai pas le temps de faire du polling dans les différentes routines donc positionner des drapeaux à partir de la routine d'interruption pour les exploiter ensuite est exclu.

J'ai eu besoin d'utiliser un tel système il y a fort longtemps en assembleur HC11 et cela consistait à mettre l'adresse de la routine voulue dans la pile à  l'adresse du vecteur de retour et de faire une instruction de sortie d'interruption.
En fait, ce noyau temps réel, je sais c'est pompeux, est constamment sous régime d'interruption.

Y a-t-il un moyen de faire de même avec un Arduino ?

Voici un aperçu de ce que souhaite réaliser :

Code:

// ------------------------
// Routine d'initialisation

void setup()
{

// Réglage de l'interruption du BP.

attachInterrupt(1, getIntBP, FALLING);
currState = state1;

}

// ----------------
// Boucle principale

void loop()
{
// Do nothing
}

//-------------------------------------
// Routine de gestion du bouton sous IT

void getIntBP()
{

switch (currState)
{
case state1:
subState2();
break;
case state2:
subState3();
break;
case state3:
subState4();
break;
case state4:
subState1();
break;
default:
subState1();

}

//-----------------
// Routine état 1

void subState1()
{
currState = state1;
while (always)
{
// Do something
}
}
//-----------------
// Routine état 2

void subState2()
{
currState = state2;
while (always)
{
// Do something
}
}

//-----------------
// Routine état 3

void subState3()
{
currState = state3;
while (always)
{
// Do something
}
}

//-----------------
// Routine état 4

void subState4()
{
currState = state4;
while (always)
{
// Do something
}

[Reply #1 on:]

Pourquoi ne pas simplement incrémenter une variable dans ton interruption, et faire un select case dans la loop ?

[Reply #2 on:]

Parce que je ne vais pas dans la boucle look sauf en sortie de setup.
Il faudrait, dans cette hypothèse, que je fasse un select case dans toutes mes routines, ce qui est trop lourd.

[Reply #3 on:]

Je crois que tu m'as pas compris, un code vaut mieux qu'un long discours ^^ :

Code:

void loop(){
switch (currState)
{
case 1:
subState2();
break;
case 2:
subState3();
break;
case 3:
subState4();
break;
case 4:
subState1();
break;
default:
subState1();

}
}
void getIntBP(){
CurrentState++;
if(CurrentState>4) CurrentState=1;
}

[Reply #4 on:]

Je ne comprends pas bien comment je peux me retrouver dans look après être passé dans une de mes boucles.
Le déroulement normal :

Je vais directement dans une des boucles et je fais des choses très "chaudes" en termes de temps. On appuie sur le bouton, donc on se retrouve dans la routine d'interruption. même si je positionne des choses dans cette routine, il va falloir que je les teste au retour et c'est cela que je veux éviter. En fait toutes mes routines sont des boucles look et le seul moyen de passer de l'une à l'autre est l'appui sur le bouton.

[Reply #5 on:]

Non mais la, tu ne reste jamais "coincer" dans une routine : la loop joue le rôle de chacun de tes while qu'il faut d'ailleurs enlever. La routine qui va boucler en continu sera celle qui correspondra au currState. Le seul moment ou tu va devoir attendre c'est que si une routine est engagée, il faut qu'elle se termine avant d'enchainer sur la routine nouvellement selectionnée.

[Reply #6 on:]

D'accord, grâce à cette discussion, j'ai pensé différemment le problème et je pense que ce que je mets en suivant va vraiment aller sans handicaper mes temps de réponse.
Merci pour t'être penché sur mon problème et d'y avoir consacré du temps, être à plusieurs, cela ouvre des perspectives nouvelles.

Code:

// ------------------------
// Routine d'initialisation

void setup()
{

// Réglage de l'interruption du BP.

attachInterrupt(1, getIntBP, FALLING);
boolean bpUp = true;

subState1();

}

// ----------------
// Boucle principale

void loop()
{
bpUp = true;
switch (currState)
{
case state1:
subState2();
break;
case state2:
subState3();
break;
case state3:
subState4();
break;
case state4:
subState1();
break;
default:
subState1();
}

//-------------------------------------
// Routine d'interruption

void getIntBP()
{
bpUp = false;
}

//-----------------
// Routine état 1

void subState1()
{
currState = state1;
while (bpUp)
{
// Do something
}
}
//-----------------
// Routine état 2

void subState2()
{
currState = state2;
while (bpUp)
{
// Do something
}
}

//-----------------
// Routine état 3

void subState3()
{
currState = state3;
while (bpUp)
{
// Do something
}
}

//-----------------
// Routine état 4

void subState4()
{
currState = state4;
while (bpUp)
{
// Do something
}

[Reply #7 on:]

Pour moi tu te compliques la vie : tu tiens à tes while alors que loop fera le job :

Code:

// ------------------------
// Routine d'initialisation

byte currState=0;

void setup()
{

// Réglage de l'interruption du BP.

attachInterrupt(1, getIntBP, FALLING);

subState1();

}

// ----------------
// Boucle principale

void loop()
{

switch (currState)
{
case 0:
subState2();
break;
case 1:
subState3();
break;
case 2:
subState4();
break;
case 3:
subState1();
break;
default:
subState1();
}

//-------------------------------------
// Routine d'interruption

void getIntBP()
{
currState++;
if(currState>3) currState=0;
}

//-----------------
// Routine état 1

void subState1()
{
// Do something
}
//-----------------
// Routine état 2

void subState2()
{
// Do something
}

//-----------------
// Routine état 3

void subState3()
{
// Do something
}

//-----------------
// Routine état 4

void subState4()
{
// Do something
}