Gestion d'interruption

inviteafdba76f · 20/06/2018, 12h48

Bonjour à tous,

j'ai vraiment besoin d'aide, je ne m'en sors pas. Mon problème repose sur une difficulté d'interruption.

Que je vous présente mon projet: J'ai pour objectif de créer un petit appareil permettant d'infuser le thé à l'aide d'une pompe en fonction de chaque type ( le temps d'infusion changera entre du thé noir et du thé vert). Pour ce faire, j'allume mon proto avec un bouton, puis je souhaite choisir mon type de thé, ceci étant indiqué par la couleur de ma LED multicolore ( Vert pour thé vert, rouge thé" rouge etc..) Je vous ai mit en PJ un morceau de synoptique.

Seulement, je n'arrive pas à gérer mes interruptions. Je n'arrive jamais à passer mon premier mode/type de thé. J'aimerai qu'au fur et à mesure des clics( je passe de programme en programme (1 clic -> programme thé vert et donc LED verte, 2ème clic programme thé rouge ...). Il y a une deuxième LED qui est censé indiquer si la température est trop chaude (vous le verrez dans la synoptique)

Merci beaucoup à ceux qui prendront le temps de m'aider. Bonne journée.

Voici le code (GPIOB1-2-3->LED, GPIOC->POMPE, GIPOD7->Bouton)

Code:

void detection2(void){
     
    In1=GPIO_ReadInputPin(GPIOD,GPIO_PIN_7);
    /*if (In1==0)
    {     
    //Si l'entrée est à 0
        In1_0++;
        In1_1=0;
        if(In1_0> Debounce)
        { In1_0=Debounce+1;
            StatoIn1=0;
         
      }
    }
    else {//si l'entrée est à 1     In1_1++;
        In1_0=0;
        In1_1++;
        if(In1_1> Debounce)
        {
            In1_1=Debounce+1;
            StatoIn1=1;
            }
        }*/
     
old_state = In1;
while (1) {
  new_state = In1;
  /* Détection d'un changement d'état */
  if (old_state != new_state) {
    if (new_state == 1) {
      /* Traitement du front montant */
    }
    else {
     choix++; /* Traitement du front descendant */
    }
    old_state = new_state;
          }
}
         
  }
 
 
void main(void)
  {
    int d=0;
     
    bool i = FALSE;
 
  CLK_Config();
    GPIO_Config();
    TIM1_Config();
    TIM4_Config(); 
    enableInterrupts();
   
   
    while(1){
//  wfi();
  detection2();
 
     
    if(choix>2)choix=0;
        switch (choix){
        case 0: 
        for (d=0;d<20000;d++){
              GPIO_WriteHigh(GPIOB,GPIO_PIN_1);
                    GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
                    GPIO_WriteLow(GPIOB,GPIO_PIN_2);
                    GPIO_WriteLow(GPIOB,GPIO_PIN_3);
                        break;
                    }
                         
        case 1:
        for (d=0;d<20000;d++){
              GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
          GPIO_WriteHigh(GPIOB,GPIO_PIN_2);
          GPIO_WriteLow(GPIOB,GPIO_PIN_1);
          GPIO_WriteLow(GPIOB,GPIO_PIN_3);
          break;
          }
                         
        case 2:
        for (d=0;d<20000;d++){
                GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
            //  GPIO_WriteHigh(GPIOB,GPIO_PIN_3);
              GPIO_WriteLow(GPIOB,GPIO_PIN_2);
              GPIO_WriteLow(GPIOB,GPIO_PIN_1);
            break;
            }
         
        
    }
     
     
}

Nom : Synoptique.jpg
Affichages : 132
Taille : 153,2 Ko

invite6486d7bd · 20/06/2018, 12h56

Une idée comme ça, pourquoi vous utilisez "break" au sein des boucles de la variable d ?

**pm42** · 20/06/2018, 13h13

Envoyé par LeMulet

Une idée comme ça, pourquoi vous utilisez "break" au sein des boucles de la variable d ?

Bonne remarque. Sans doute parce qu'il pensait les mettre dans le switch/case mais comme elles se retrouvent dans la boucle, elles l'arrêtent.
Et le break du switch/case n'est pas fait lui.

inviteafdba76f · 20/06/2018, 14h34

Bonjour les gars,
oui c'est ça, je pensait que lorsque j'utilisais un switch, je devais mettre un break par choix possible . Dois je les enlever ?

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

**pm42** · 20/06/2018, 15h00

Non, juste les mettre au bon endroit, c'est à dire pas entre les accolades de tes boucles for().

inviteafdba76f · 20/06/2018, 15h40

Merci PM. ALors maintenant, me led clignotte du vert au bleu alors que j'ai trois sortie ( GIPOB1->vert ; GBPIOB2-> bleu ;GPIOB3->rouge). La led clignotte du vert au bleu, puis lorsque je rappui elle s'arrête sur une de ces deux couleurs. Lorsque je rappui, je repars dans un mode clignotant. Je ne comprends pas.

**JPL** · 20/06/2018, 16h29

Envoyé par jerepout

Bonjour les gars

Pourquoi uniquement les gars ?

inviteafdba76f · 20/06/2018, 16h38

Car j'ai supposé que selon les pseudo c'était des gars. Mais je n'en sais rien, c'est vrai

**pm42** · 20/06/2018, 16h46

Envoyé par jerepout

Merci PM. ALors maintenant, me led clignotte du vert au bleu alors que j'ai trois sortie ( GIPOB1->vert ; GBPIOB2-> bleu ;GPIOB3->rouge). La led clignotte du vert au bleu, puis lorsque je rappui elle s'arrête sur une de ces deux couleurs. Lorsque je rappui, je repars dans un mode clignotant. Je ne comprends pas.

Vu qu'on ne sait pas ce que tu as fait, cela devient plus compliqué de t'aider.

inviteafdba76f · 20/06/2018, 16h47

j'ai mis les break en dehors de la boucle for

**pm42** · 20/06/2018, 16h50

Envoyé par jerepout

j'ai mis les break en dehors de la boucle for

Je vais être plus précis : peux tu poster ton code modifié ?

inviteafdba76f · 20/06/2018, 17h04

Code:

 

void detection2(void){
	
	In1=GPIO_ReadInputPin(GPIOD,GPIO_PIN_7);
	/*if (In1==0)
	{      
	//Si l'entrée est à 0
	 	In1_0++;
		In1_1=0;
		if(In1_0> Debounce)
		{ In1_0=Debounce+1;
			StatoIn1=0;
		
  	  }
	}
	else {//si l'entrée est à 1		In1_1++;
		In1_0=0;
		In1_1++;
		if(In1_1> Debounce)
		{
		 	In1_1=Debounce+1;
			StatoIn1=1;
			}
		}*/
	
old_state = In1;
delay(1000);
while (1) {
  new_state = In1;
  /* Détection d'un changement d'état */
  if (old_state != new_state) {
    if (new_state == 1) {
      /* Traitement du front montant */
    }
    else {
     choix++; /* Traitement du front descendant */
    }
    old_state = new_state;
		  }
}
		
  }


void main(void)
  {	
	int d=0;
	
	bool i = FALSE;

  CLK_Config();
	GPIO_Config();
	TIM1_Config(); 
	TIM4_Config();  
	enableInterrupts();
  
  
	while(1){
	wfi();
 detection2(); 

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

}

invite1c6b0acc · 20/06/2018, 21h21

Bonjour,

La fonction detection2() initialise old_state et new_state à la même valeur et boucle sans fin en ne faisant rien puisque old_state et new_state ont la même valeur.

Donc, on ne sort jamais de detection2() et elle ne fait rien.

Donc déplacer tes "breaks" n'a pas pu changer le résultat.

D'autre part; ce serait plus simple si tu nous donnais tout ton code et pas seulement une partie choisie arbitrairement. Parce que j'imagine que les variables sont bien déclarées quelque part. (Ce sont toutes des variables globales ?

)

inviteafdba76f · 21/06/2018, 10h50

Oui,
je pense que c'est ma fonction détection front montant qui n'est pas bonne. Voici mon code cher PM:

Code:

#include "stm8s.h"
#include "stm8s_gpio.h"
#include "stm8s_conf.h"
#include "stm8s_itc.h"
#include "stdio.h"
#include "stdlib.h"


//#include "windows.h"
#define T_thevert 20000 
#define T_thenoir 20000 
#define T_therouge 20000
int i,d;
//volatile int mode;
volatile int StatoIn1;

//u16 StatoIn1;
u16 tempo = 0;
u16 choix =0;
u8 In1=3;
u16 In1_0=0;
u16 In1_1=0;
u16 Debounce=10;// 1000 pour 1 seconde ; 10 ferait 10 ms
int old_state;
int new_state;

/* Private function prototypes -----------------------------------------------*/ 
void TIM1_Config(void); 
void TIM4_Config(void); 
/* Private functions ---------------------------------------------------------*/ 
/* Public functions ----------------------------------------------------------*/ 
void delay (uint16_t nCount); 


void delay(uint16_t nCount) 
{ 
  /* Decrement nCount value */ 
  while (nCount != 0) 
  { 
    nCount--; 
  } 
} 

static void CLK_Config(void) // configuration Quartz 16 MHz
{   CLK_DeInit( );
    CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);      //f_Master = HSI/1 = 16MHz
    CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);            //f_CPU = f_Master/1 = 16MHz
    while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY)!=SET);     //wait until HSI ready 
}

void TIM4_Config(void){
	TIM4_DeInit(); // 1 impulsion toute les ms
	TIM4_TimeBaseInit(TIM4_PRESCALER_128, 0x7D);   // Interruption toutes les  1 ms
	TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);//Configuration
	TIM4_Cmd(ENABLE);  //Activation TIM4
}

void TIM1_Config(void) 
{ 
    CLK_PeripheralClockConfig (CLK_PERIPHERAL_TIMER1 , ENABLE);     
    TIM1_DeInit(); 
    TIM1_TimeBaseInit(16, TIM1_COUNTERMODE_DOWN, 100, 0); //timer freq = (clock CPU/16) -> 1bit = 1uS -> 100uS
    TIM1_ITConfig(TIM1_IT_UPDATE, ENABLE); 
    TIM1_Cmd(ENABLE); 
} 

void GPIO_Config(void){
	CLK_Config();
	TIM4_Config();
  GPIO_DeInit(GPIOB); 
	GPIO_DeInit(GPIOC); 
  GPIO_DeInit(GPIOD);
	GPIO_Init(GPIOB, GPIO_PIN_1 , GPIO_MODE_OUT_PP_LOW_FAST); 
	GPIO_Init(GPIOB, GPIO_PIN_2 , GPIO_MODE_OUT_PP_LOW_FAST);
	GPIO_Init(GPIOB, GPIO_PIN_3 , GPIO_MODE_OUT_PP_LOW_FAST);
	GPIO_Init(GPIOD, GPIO_PIN_0 , GPIO_MODE_OUT_PP_LOW_FAST);
	GPIO_Init(GPIOD, GPIO_PIN_6 , GPIO_MODE_IN_PU_NO_IT);
	GPIO_Init(GPIOC, GPIO_PIN_1 , GPIO_MODE_OUT_PP_LOW_FAST);
	GPIO_Init(GPIOC, GPIO_PIN_2 , GPIO_MODE_OUT_PP_LOW_FAST);
	GPIO_Init(GPIOC, GPIO_PIN_3 , GPIO_MODE_OUT_PP_LOW_FAST);
	GPIO_Init(GPIOD, GPIO_PIN_7 , GPIO_MODE_IN_PU_NO_IT);
	GPIO_Init(GPIOB, GPIO_PIN_7 , GPIO_MODE_IN_PU_NO_IT);
}


 


void detection2(void){
	
	In1=GPIO_ReadInputPin(GPIOD,GPIO_PIN_7);
	/*if (In1==0)
	{      
	//Si l'entrée est à 0
	 	In1_0++;
		In1_1=0;
		if(In1_0> Debounce)
		{ In1_0=Debounce+1;
			StatoIn1=0;
		
  	  }
	}
	else {//si l'entrée est à 1		In1_1++;
		In1_0=0;
		In1_1++;
		if(In1_1> Debounce)
		{
		 	In1_1=Debounce+1;
			StatoIn1=1;
			}
		}*/
	
old_state = In1;
delay(1000);
while (1) {
  new_state = In1;
  /* Détection d'un changement d'état */
  if (old_state != new_state) {
    if (new_state == 1) {
      /* Traitement du front montant */
    }
    else {
     choix++; /* Traitement du front descendant */
    }
    old_state = new_state;
		  }
}
		
  }


void main(void)
  {	
	int d=0;
	
	bool i = FALSE;

  CLK_Config();
	GPIO_Config();
	TIM1_Config(); 
	TIM4_Config();  
	enableInterrupts();
  
  
	while(1){
	wfi();
 detection2(); 

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

}

**pm42** · 21/06/2018, 11h12

La dernière personne à t'avoir répondu est Chanur pour rendre à César ce qui lui appartient.

inviteafdba76f · 21/06/2018, 13h12

En effet, merci également chanur. J'ai remplacé mon while dans detection2 par une boucle for mais rien n'y fait. J'ai relu ligne par ligne, la logique me semble bonne, je ne comprends pas.

**CM63** · 21/06/2018, 14h30

Bonjour,

Recolle-nous ta fonction detection2 qu'on voie ce qui ne va pas.

inviteafdba76f · 21/06/2018, 14h35

Code:


void detection2(void){
	
	In1=GPIO_ReadInputPin(GPIOD,GPIO_PIN_7);
	/*if (In1==0)
	{      
	//Si l'entrée est à 0
	 	In1_0++;
		In1_1=0;
		if(In1_0> Debounce)
		{ In1_0=Debounce+1;
			StatoIn1=0;
		
  	  }
	}
	else {//si l'entrée est à 1		In1_1++;
		In1_0=0;
		In1_1++;
		if(In1_1> Debounce)
		{
		 	In1_1=Debounce+1;
			StatoIn1=1;
			}
		}*/
	
old_state = In1;
delay(1000);
for(i=0;i>1000;i++){
  new_state = In1;
  /* Détection d'un changement d'état */
  if (old_state != new_state) {
    if (new_state == 1) {
      /* Traitement du front montant */
    }
    else {
     choix++; /* Traitement du front descendant */
    }
    old_state = new_state;
		  }
}
		
  }

inviteafdba76f · 22/06/2018, 11h12

Du tout, je travaille sur STM8S. Sinon j'ai fait un anti-rebond qui est pour l'instant en commentaire. Merci de votre aide

Code:

In1=GPIO_ReadInputPin(GPIOD,GPIO_PIN_7);
	/*if (In1==0)
	{      
	//Si l'entrée est à 		In1_1=0;0
	 	In1_0++;

		if(In1_0> Debounce)
		{ In1_0=Debounce+1;
			StatoIn1=0;
		
  	  }
	}
	else {//si l'entrée est à 1		In1_1++;
		In1_0=0;
		In1_1++;
		if(In1_1> Debounce)
		{
		 	In1_1=Debounce+1;
			StatoIn1=1;
			}
		}*/

invite1c6b0acc · 22/06/2018, 15h13

Oublions la partie en commentaire pour l'instant.

Actuellement, direction2() fait 4 choses :
- elle met dans In1, old_state et new_state la valeur de retour de GPIO_ReadInputPin()
- elle décrémente 1000 fois nCount
- elle incrémente 1000 fois i
- elle vérifie 1000 fois que old_state et new_state gardent la même valeur.

Il n'est pas du tout question de détection de front montant ...

J'imagine que ce que tu voudrais faire, c'est comparer la nouvelle valeur de GPIO_ReadInputPin() à l'ancienne.
Dans ce cas là, ce serait sûrement mieux de ne pas commencer par écraser l'ancienne valeur

La boucle (sans fin ou limitée à 1000 itérations) n'a aucun sens : puisque tu ne relances pas GPIO_ReadInputPin(), tu n'as aucune nouvelle information, d'une itération à l'autre.

J'aurais plutôt fait un truc du genre :

Code:

static int choix = 0;
static u16 old_state = 0;
u16 new_state = GPIO_ReadInputPin (GPIOD,GPIO_PIN_7);
if (old_state ==0 && new_state == 1)
    {
    choix++;
    }
old_state = new_state;
return choix;

J'ai supposé que direction2() retourne son résultat, plutôt que de passer par une variable globale.
Il est nettement préférable d'utiliser des variables locales et des fonctions qui retournent une valeur plutôt que de tout faire avec des variables globales : regarde, par exemple ta boucle for(i=0;i<1000;i++). Si dans cette boucle tu appelles une fonction, celle-ci a la possibilité de modifier la variable i. Tu n'as pas envie que ça se produise ...

Une autre façon de faire est que la fonction soit bloquante tant qu'il n'y a pas de front montant. Dans ce cas, il faut une boucle dont la condition de fin soit le fait d'avoir détecté un front montant, et il faut relancer GPIO_ReadInputPin() à chaque itération.

Deux autres remarques : la fonction Delay() est absurde (elle utilise tout le temps CPU) ; et puisque la fonction direction2() sert à détecter les fronts montants, pourquoi ce nom ? Moi je l'aurais appelée "detection_front_montant".

inviteafdba76f · 25/06/2018, 10h32

Merci beaucoup Charnur de toutes ces informations. En effet, j'avais fait des choses pas hyper logique, et grâce à toi je les ai comprise. Mais une question me taraude. Il sort une tension de 5 V de ma pin7, et donc à l'appui, je descend à 0,puis je reviens à cette tension. Dois je vraiment utiliser un front montant ?
Je n'ai aucun soucis pour la compilation de la fonction que j'ai renommé détection_front_montant mais plus rien ne se passe. Je ne semble pas rentrer dans un mode car aucune LED ne s'allume

**antek** · 25/06/2018, 11h36

Envoyé par jerepout

Dois je vraiment utiliser un front montant ?

C'est selon ce que tu veux réaliser.
Pour une prise en compte immédiate de l'appui il faut détecter le front descendant.

inviteafdba76f · 25/06/2018, 11h57

Ah mince, c'est en effet ce que je veux. De plus, je ne suis pas sur de moi mais sauriez vous si la fonction détection est bien active "constamment". En gros, quelle est bien appelé dès qu'il y a un appui, et qu'elle incrément bien la valeur du main.

**antek** · 25/06/2018, 12h14

Envoyé par jerepout

De plus, je ne suis pas sur de moi mais sauriez vous si la fonction détection est bien active "constamment" . . .

J'ai déjà du mal pour faire les miens en C, alors conseiller . . .
Mais quand une interruption est mise en fonction elle réagit en permanence !

inviteafdba76f · 25/06/2018, 12h27

J'en doute pour le coup. Merci de ton aide et courage dans tes projets !

invite1c6b0acc · 25/06/2018, 12h39

Envoyé par jerepout

Ah mince, c'est en effet ce que je veux. De plus, je ne suis pas sur de moi mais sauriez vous si la fonction détection est bien active "constamment". En gros, quelle est bien appelé dès qu'il y a un appui, et qu'elle incrément bien la valeur du main.

Ben non. Pourquoi elle ferait ça ?
Heureusement que le système ne lance pas n'importe quelle fonction sans qu'on lui demande !

La, tu déclares une fonction, et tu la lances dans une boucle du main().
Elle s'exécute à chaque fois que tu la lances, c'est tout. Et il me semble que c'est ce que tu veux, ou j'ai mal compris ?

La seule chose qui parle d'interruption, c'est le titre de cette discussion, pas ton programme.

inviteafdba76f · 25/06/2018, 12h42

Je veux en effet l'appeler à chaque fois que j'en ai besoin. Je viens de comprendre.

inviteafdba76f · 25/06/2018, 12h46

Dans l'état actuel, la led verte reste constamment allumé. Je ne comprends pas comment cela est possible, car j'ai limité son allumage par une boucle for non ? ( cas 0 ) .

Code:





int detection_front_descendant(void){
	static u16 old_state = 1;
	static int choix; 
	

u16 new_state = GPIO_ReadInputPin(GPIOD,GPIO_PIN_7);
if (old_state ==1 && new_state == 0)
    {
    choix++;
    }
old_state = new_state;
return choix;		
  }


void main (void) {	
	int d=0;
	bool i = FALSE;
	  int mode;
	static int StatoIn;
	
  CLK_Config();   
	GPIO_Config();
	TIM1_Config(); 
	TIM4_Config();  
	enableInterrupts();

 detection_front_montant();

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

inviteafdba76f · 25/06/2018, 15h04

Je viens de simplifier le code, en sortant la fonction interruption du main.c et de reprendre ce que tu m'avais dit. Je m'approche du but car la led change de couleur lors d'un appui, mais la couleur est hasardeuse ( je ne suis pas la chronologie du code)

Code:

void main (void) {	
	int d=0;
	bool i = FALSE;
	  int mode;
	static int StatoIn;
	
  CLK_Config();   
	GPIO_Config();
	TIM1_Config(); 
	TIM4_Config();  
	enableInterrupts();
	
 //detection_front_montant();
while(1){
	//detection();
	wfi();
	if(choix>2)choix=0;
		switch (choix)
		{
		case 0:	 
		for (d=0;d<2000;d++){
		      GPIO_WriteHigh(GPIOB,GPIO_PIN_1);
					GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
					GPIO_WriteLow(GPIOB,GPIO_PIN_2);
					GPIO_WriteLow(GPIOB,GPIO_PIN_3);
					}break; 
						
		case 1:
		for (d=0;d<2000;d++){
			  GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
	      GPIO_WriteHigh(GPIOB,GPIO_PIN_2);
	      GPIO_WriteLow(GPIOB,GPIO_PIN_1);
	      GPIO_WriteLow(GPIOB,GPIO_PIN_3);
	      }break;
						
		case 2: 
		for (d=0;d<2000;d++){
				GPIO_WriteHigh(GPIOC,GPIO_PIN_1);
				GPIO_WriteHigh(GPIOB,GPIO_PIN_3);
			  GPIO_WriteLow(GPIOB,GPIO_PIN_2);
			  GPIO_WriteLow(GPIOB,GPIO_PIN_1);
		  	} break;
		
		} 
	
	}
	
}


// Fichier stm8_it.c

 INTERRUPT_HANDLER(TIM4_UPD_OVF_IRQHandler, 23)
{ 
static int StatoIn1;
StatoIn1=GPIO_ReadInputPin(GPIOD, GPIO_PIN_7);	
if(StatoIn1==0){choix++;}
TIM4_ClearITPendingBit(TIM4_IT_UPDATE); 
 }

Gestion d'interruption

Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Re : Gestion d'interruption

Discussions similaires

[Programmation] Gestion d'interruption

Probleme de gestion d'interruption pic18

Gestion Interruption PIC18F

[PIC]- Gestion Interruption -> Module EUSUART

Gestion des interruption avec un PIC