Gestion switch case

inviteafdba76f · 26/07/2018, 09h57

Bonjour à tous,
sauriez vous comment sortir d'un case switch après un temps donné?
En gros, j'aimerai allumé ma LED que 1 min, et qu'elle s'éteigne ensuite. Or, pour l'instant, elle s'allume indéfiniment.
Merci pour votre aide

Code:

switch(choix)
{
case 1: while(d<10000){
d++;
GPIO_WriteLow(GPIOC,GPIO_PIN_1);
GPIO_WriteLow(GPIOB,GPIO_PIN_1);
GPIO_WriteLow(GPIOB,GPIO_PIN_2);
GPIO_WriteLow(GPIOB,GPIO_PIN_3);
}
//d=0;
// choix=0;
break;

case 2:
while(d<1000){
d++;
GPIO_WriteHigh(GPIOB,GPIO_PIN_1);
GPIO_WriteHigh(GPIOC,GPIO_PIN_1); //Verte
GPIO_WriteLow(GPIOB,GPIO_PIN_2);
GPIO_WriteLow(GPIOB,GPIO_PIN_3);
}

}

invite73192618 · 26/07/2018, 21h53

Ton switch doit être mis dans une boucle. Autrement dit le problème n'est pas de savoir comment sortir mais comment rester, la solution usuelle étant de re rentrer dans le switch.

**Ikhar84** · 26/07/2018, 23h10

Il y a trois façon principale de gérer le temps, demander au processus de "s'endormir" un certain temps (un entier qui représente le nombre de ms, soit 1 000 pour une seconde), soit invoquer une sorte de chrono, un timer, qui va déclencher une série d'instruction à chaque "tick", soit à une période choisie, enfin, la méthode crado, empirique, et non portable, qui va effectuer des instructions bidons dans une boucle (en général un for)... ici sûrement ton

Code:

int d=0;
while(d<10000){
   d++;
   ...
}

La première serait la meilleure ici, on allume la led, on fait un sleep de 1 000 ms, pour mettre en pause le processus, puis on eteind la led...

La sortie du SWITCH se fait ensuite classiquement grâce à l'instruction BREAK...

Accessoirement, sans le code au complet, on présume du rôle de "d", et on ne connaît rien de choix, tu peux d'ailleurs utiliser des constantes pour que le switch soit plus lisible qu'avec les valeur 1 et 2 qui sont de toute façon des constantes mais littérales...

Edit: après vérification, pour Arduino pas de sleep (qui met le proc en veille) mais un delay (unsigned long ms)

inviteafdba76f · 31/07/2018, 13h41

Je suis toujours autant bloqué

A voir en vidéo sur Futura · Aujourd'hui

**Ikhar84** · 31/07/2018, 14h18

Ben essaies déjà de donner plus d'infos sur ton système (arduino, rasp ?), même si ton GPIO_ donne un indice...

Ensuite, dégages ton

Code:

While (d<10000){
}

Quand tu as allumé ta led, tu imposes un délai en millisecondes, puis tu l'éteinds.

inviteafdba76f · 31/07/2018, 15h21

Bonjour,
je ne voulais pas paraître désobligeant, veuillez m'excusez. Le problème étant que si je met un delay, je ne peut sortir du case correspondant si je ré-appui une nouvelle fois sur le bouton.
Je voudrais que un appui entraine la mise au vert de la led durant une minute, et qu'un deuxième entraine la mise en bleu de la led avec une tempo de deux minutes.

invite73192618 · 31/07/2018, 16h00

Envoyé par jerepout

si je met un delay, je ne peut sortir du case correspondant si je ré-appui

Oui, c'est le problème d'utiliser des delay. Une meilleure alternative est de passer par la méthode "invoquer un chrono" comme suit:

Code:

Tant que vrai
    Si bouton bleu
        Cible 1 = heure actuelle  + une seconde
        Allume Led bleu
    Si bouton vert
        Cible 2 = heure actuelle + dix secondes
        Allume Led verte
    Si heure actuelle > cible 1
        Éteint Led bleu
    Si heure actuelle > cible 2
        Éteint Led verte
Fin boucle tant que

inviteafdba76f · 31/07/2018, 16h05

Lorsque l'on fait une boucle for, ce n'est pas la même chose mais d'une autre manière, au sens où on incrémente une variable, et l'on met en ON les fonctions à l'intérieur de la boucle tant que la valeur incrémentée n'a pas dépassée un certain seuil.

**Ikhar84** · 31/07/2018, 18h03

La boucle for n'est vraiment pas faite pour gérer le temps.
Si on attend de nouveaux appuis ou de nouveaux traitement, il vaut mieux ne pas utiliser de delay mais un timer comme dit par Jiav plus haut.

invite73192618 · 31/07/2018, 23h26

En fait le problème ne serait pas vraiment la boucle for. Deux petits programmes pour illustrer :

Code:

for i = 1:100000000000000000000000
    Si bouton bleu
        Cible 1 = heure actuelle  + une seconde
        Allume Led bleu
    Si bouton vert
        Cible 2 = heure actuelle + dix secondes
        Allume Led verte
    Si heure actuelle > cible 1
        Éteint Led bleu
    Si heure actuelle > cible 2
        Éteint Led verte
Fin boucle for

Dans ce cas de figure le programme est presque portable, le seul inconvénient du for (outre son uglytude et son absence totale davantage sur le while) étant que le programme s'arrête tout seul au bout d'un certain temps (temps qui dépend des détails matériels). À l'inverse on peut errer avec un while de cette manière:

Code:

compteur = 0
Tant que vrai
    compteur =+
    Si bouton bleu
        Cible 1 = compteur + 1000
        Allume Led bleu
    Si bouton vert
        Cible 2 = compteur + 10000
        Allume Led verte
    Si compteur > Cible 1
        Éteint Led bleu
    Si compteur > Cible 2
        Éteint Led verte
Fin boucle tant que

Dans ce cas de figure le programme pourrait fonctionner, mais il ne sera pas du tout portable, c'est-à-dire que le comportement variera beaucoup en fonction du matériel. C'est ce défaut que signale Ikhare84.

**pm42** · 01/08/2018, 06h07

Envoyé par Jiav

Dans ce cas de figure le programme pourrait fonctionner, mais il ne sera pas du tout portable, c'est-à-dire que le comportement variera beaucoup en fonction du matériel.

Il va aussi consommer de la CPU pour rien ce qui va faire chauffer le processeur, bouffer de l'énergie...

inviteafdba76f · 01/08/2018, 10h31

Oui, c'est ce qui me pose problème avec ces solutions,c 'est en premier lieu la consommation du CPU.
Quelle est alors la solution la moins consommatrice ? Faire intervenir un timer au sein du switch ? C'est possible?
Que se passe t-il lorsque la boucle est terminée ? Je sors du switch ?

Merci infiniment pour votre aide les gars

**pm42** · 01/08/2018, 10h39

Envoyé par jerepout

Oui, c'est ce qui me pose problème avec ces solutions,c 'est en premier lieu la consommation du CPU.
Quelle est alors la solution la moins consommatrice ? Faire intervenir un timer au sein du switch ? C'est possible?
Que se passe t-il lorsque la boucle est terminée ? Je sors du switch ?

Tout dépend de la structure de ton programme, des librairies disponibles, etc. Mais en gros, l'idéal est d'allumer ta LED puis d'enregistrer une tâche qui va l'éteindre dans 1 min dans un scheduler.

inviteafdba76f · 01/08/2018, 10h42

En langage C ? Je n'ai jamais entendu ce terme. Je vais faire mes recherches.
Je suis preneur de toute solution

**pm42** · 01/08/2018, 10h51

Envoyé par jerepout

En langage C ? Je n'ai jamais entendu ce terme. Je vais faire mes recherches.
Je suis preneur de toute solution

Oui, en langage C. Tu programmes dans quel environnement ? Arduino ? Raspberry ?
Ton programme a quoi comme boucle principale ?

inviteafdba76f · 01/08/2018, 10h54

SLangage C , et je travaille sur un STM8S

Voici mon code principal, j'y ai enlevé les boucles puisqu'elles me bloquaient.

Code:

void main (void) {	
	
	int d=0;
	bool i = FALSE;
	int mode;
	static int StatoIn;
  //int choix=0;
  int tempsappui=0;
  CLK_Config();   
  GPIO_Config();



while(1){
	int appuiclean=0;
	
 if (tempsappui>1000)choix=1;

     
 
	
if(GPIO_ReadInputPin(GPIOD, GPIO_PIN_7) == FALSE){
 tempsappui++;
 choix++; }


if(choix>5)choix=1;
 if (choix<5){
		switch(choix)
		{	 case 0: 
		for (d=0;d<20000;d++){ tempo++; 
         { 
        if (tempo>500) 
				GPIO_WriteHigh(GPIOB, GPIO_PIN_3);         		
				tempo=0;  
        }GPIO_WriteLow(GPIOB, GPIO_PIN_1);
				 GPIO_WriteLow(GPIOB, GPIO_PIN_2);			
				}break; 
				
			case 1: 
   			GPIO_WriteLow(GPIOC,GPIO_PIN_1);
	      GPIO_WriteLow(GPIOB,GPIO_PIN_1);       
	      GPIO_WriteLow(GPIOB,GPIO_PIN_2);
		  	GPIO_WriteLow(GPIOB,GPIO_PIN_3);   
				break;
				
			case 2:    
{			
				GPIO_WriteHigh(GPIOB,GPIO_PIN_1);
				GPIO_WriteHigh(GPIOC,GPIO_PIN_1); //Verte
				GPIO_WriteLow(GPIOB,GPIO_PIN_2);
		  	         GPIO_WriteLow(GPIOB,GPIO_PIN_3);
				
				
				
				GPIO_WriteLow(GPIOC,GPIO_PIN_1);
	      GPIO_WriteLow(GPIOB,GPIO_PIN_1);       
	      GPIO_WriteLow(GPIOB,GPIO_PIN_2);
		  	GPIO_WriteLow(GPIOB,GPIO_PIN_3);   
				
				break;
		

	
		  case 3:
	  	  GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
	      GPIO_WriteHigh(GPIOB,GPIO_PIN_2); //Bleue    
	      GPIO_WriteLow(GPIOB,GPIO_PIN_1);
	      GPIO_WriteLow(GPIOB,GPIO_PIN_3);
	      break; 
				        
       
			case 4:	
			  GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
	      GPIO_WriteHigh(GPIOB,GPIO_PIN_3); //Rouge
	      GPIO_WriteLow(GPIOB,GPIO_PIN_1);
	      GPIO_WriteLow(GPIOB,GPIO_PIN_2);
				break; 
			 
	  	case 5:	  
			  GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
	      GPIO_WriteHigh(GPIOB,GPIO_PIN_3); //Blanc
	      GPIO_WriteHigh(GPIOB,GPIO_PIN_1);
	      GPIO_WriteHigh(GPIOB,GPIO_PIN_2);
	      break;
	  



}



}

}

}

**pm42** · 01/08/2018, 11h04

Effectivement, dans un code comme celui là où tu gères toi même la boucle principale, pas de timer. Tu peux donc allumer, faire un sleep pendant 1 min puis éteindre.
Mais pendant ce temps là, tu ne vas répondre à aucun autre événement potentiel. C'est pour cela qu'on évite ce genre de solution.

Note que ta ligne

Code:

 if (choix<5){

devrait être

Code:

 if (choix<=5){

inviteafdba76f · 01/08/2018, 11h11

En effet, il faut rajouter le "=".
Et oui, je ne peux faire intervenir d'autres évènements et c'est ce qui me pose problème. C'est rédibitoire, je dois forcément avori la main mise même si un processus LED est enclenché.
Alala je galère...
Comment me sortir de l'idée du switch alors ?
C'est à dire , créer un programme structuré en fonction d'un nombre d'appui.

**pm42** · 01/08/2018, 11h18

Tu as plusieurs solutions :
- si ton environnement supporte le multi-threading, tu allumes et tu crées un thread qui dort 1 min puis éteint.
- si ton environnement te fournit le concept de boucle principale et que tu peux simplement coder les réactions à différents évènements au lieu d'écrire une fonction main toi même, tu utilises ça
- sinon, tu fais toi même une boucle qui attend des évènements et qui y réagit : je ne connais pas assez ton environnement pour savoir comme on y fait ça
- une solution élémentaire est de faire une boucle principale qui traite les évènements à intervalle régulier. Par ex, ta boucle regarde s'il y a une touche de pressée et traite. Puis elle regarde si quelle heure il est et si tu as enregistré dans une variable une heure où éteindre une LED. Si cette heure est dépassée elle le fait. Puis tu fais un sleep pendant 1 centième de seconde ou un 1 dixième de seconde par ex.

inviteafdba76f · 01/08/2018, 11h24

Merci , je vazis essayer de digérer tout ça, et de trouver la solution qui me paraît la plus judicieuse. Merci

Gestion switch case

Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Re : Gestion switch case

Discussions similaires

Aide pour un switch[case]

langage C incrementation dans switch case....

Switch ou mini switch?

[SYNOPTIQUE] - Comment réaliser une fonctions : switch(..) case ...

Utilisation de switch avec un autre switch