Ma première fonction ne fonctionne pas

Version imprimable

Bonjour,
j'ai ce petit bout de code qui créer un ON/OFF avec un poussoir.
si on appui la LED s'allume est reste allumé si on relâche le bouton.
Si on appui encore une fois la LED s'éteint.
ça fonctionne parfaitement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
const int boutonPin = 2;    //pin pour le bouton
const int ledPin =  13;     //pin pour la lED
 
int interrupteur = LOW;       //valeur de l'interrupeteur
int etatBouton = 0;             //valeur pour changement d'état du bouton
int boutonState = 0;        //etat fugitif du bouton   
 
 
void setup() {
  Serial.begin(9600);
  // Initialisation de la LED en sortie
  pinMode(ledPin, OUTPUT);     
  // Initialisation du bouton en entrée
  pinMode(boutonPin, INPUT);   
}
 
void loop(){
  Serial.println(interrupteur);
  // Lecture de l'état du bouton
  boutonState = digitalRead(boutonPin);
 
  //On regarde si le bouton est pressé
  if (boutonState == HIGH) {   
    //on regarde si il y a un changement d'état
    if (etatBouton == 1) {
      // on change l'état du bouton
      interrupteur=!interrupteur;
      // on reinitialise le etatBouton
      etatBouton=0;
      // on affiche l'état de l'interupteur virtuel sur la led
      digitalWrite(ledPin, interrupteur);
      delay(50);
    } 
  }   else {
    //le bouton n'est pas pressé, on active le etatBouton
    etatBouton=1;
  }
}

Maintenant je souhaite créer une fonction !
Les chose se compliquent. Pourquoi ma fonction renvoie "0" en permanence ?? :smiley-confuse: l
j'ai besoin d'aide:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
const int boutonPin = 2;    //pin pour le bouton
const int ledPin =  13;     //pin pour la lED
 
void setup() {
  Serial.begin(9600);
  // Initialisation de la LED en sortie
  pinMode(ledPin, OUTPUT);     
  // Initialisation du bouton en entrée
  pinMode(boutonPin, INPUT);   
}
 
void loop(){
  Serial.println(interrupteur());
}
bool interrupteur() {
    bool interrupteur = LOW;//valeur de l'interrupeteur
    int etatBouton = 0; //valeur pour changement d'état du bouton
    int boutonState = 0;//Dernier etat du bouton   
    // Lecture de l'état du bouton
    boutonState = digitalRead(boutonPin);
    if (boutonState == HIGH) {   
      //si il y a un changement d'état
     if (etatBouton == 1) {
       // on change l'état du bouton
       interrupteur=!interrupteur;
       // on reinitialise le etatBouton
          etatBouton=0;
          } 
     }   
    else {
         //le bouton n'est pas pressé, on active le etatBouton
      etatBouton=1;
     }
return (interrupteur);
}

17/12/2019, 20h49
Auteur

bonsoir,

Des indications :
- quelle est la particularité des variables définies dans une fonction (que l'on appelle aussi variables locales) ?
- que penses-tu de tes variables etatBouton et boutonState ?
17/12/2019, 22h44
Spk200

Citation:

Envoyé par Auteur

bonsoir,

Des indications :
- quelle est la particularité des variables définies dans une fonction (que l'on appelle aussi variables locales) ?
- que penses-tu de tes variables etatBouton et boutonState ?

Très bonne questions que tu me pose !:weird:
Je me doute bien que tu essaie de me faire poser les bonnes questions mais je ne voie pas ...

Sortie de la fonction elle n'existe pas pour le reste du code ? c'est aussi pourquoi je les déclares les variables à l'intérieure de la fonction .
le chois du nom "boutonState"n'est pas claire pour la compréhension du code mais cela ne remet pas en cause sont fonctionnement.

j'ai beau chercher je comprend pas .
je me suis documenté ici :https://eskimon.fr/tuto-arduino-106-...ion-typ%C3%A9e
à part le" return (interrupteur);" qui aurait du être" return interrupteur;"
18/12/2019, 00h03
al1_24

Un petit pas de plus vers la compréhension de ton problème :
Une variable locale n'est connue qu'à l'intérieur de sa portée (ici une fonction) et sa valeur disparait avec elle dès que l'on sort de cette portée.
18/12/2019, 08h41
Spk200

Citation:

Envoyé par al1_24

Un petit pas de plus vers la compréhension de ton problème :
Une variable locale n'est connue qu'à l'intérieur de sa portée (ici une fonction) et sa valeur disparait avec elle dès que l'on sort de cette portée.

Merci de ton retour,
Oui tout à fait d'accord mais le return retourne bien la variable interrupteur ? donc cette variable existe bien en dehors de la fonction à chaque fois quelle est appelé? Par contre etatBouton et boutonState n'existe plus sortie de la fonction. Ok ça tombe bien car j'en ai pas besoins une fois que ma variable intérupteur a été modifiée.

Tu veux dire qu'il faut créer une variable par exemple int retourDeMaFonction=interupteur(); dans le loop?
18/12/2019, 09h59
Spk200

Citation:

Tu veux dire qu'il faut créer une variable par exemple "int retourDeMaFonction=interupteur(); dans le loop?

:calim2::cry:

Ce n'est pas ça je viens de tester ça marche pas

Ce n'est pas ta variable "interrupteur" qui pose problème mais "etatBouton" qui est déclarée dans ta fonction. Lorsque tu quittes la fonction, elle n'existe plus, sa valeur n'est pas mémorisée. Quand tu appelles à nouveau ta fonction, tu la crées et tu lui affectes une valeur par défaut, ici 0.

Ensuite, regarde ta fonction, lis les instructions, note les valeurs de tes variables après chaque instruction. Pose toi des questions :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
bool interrupteur() 
{
 
 
    bool interrupteur = LOW;
    int etatBouton = 0; 
    int boutonState = 0;
 
// quelles sont les variables qui existent, les variables locales, les variables globales, leurs valeurs ?
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?
 
 
    boutonState = digitalRead(boutonPin);
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?
 
	if (boutonState == HIGH) // condition juste ou fausse ?
	{   
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?
 
		if (etatBouton == 1) // condition juste ou fausse ? 
		{
			interrupteur=!interrupteur;
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?       
 
			etatBouton=0;		
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?			
		} 
 
 
	}   
    else 
	{
 
		etatBouton=1;
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?		
	}
 
	return (interrupteur);
// A ce niveau de ta fonction que valent interrupteur, etatBouton, boutonState ?	
// Fin de la fonction : quelle est la valeur retournée, quelles sont les variables détruites ?
}

18/12/2019, 13h45
Spk200

Ok du fait que ma variable " etatBouton " est initialisé a 0 mon if (etatBouton == 1) est FAUX donc ça marche pas

en admettant que etatBouton soit initialisé à 1 la ma fonction change d’état mais ne garde pas la mémoire car j'initialise bool interrupteur = LOW en début de fonction.
Mon else ne rien à rien au passage...
Mais alors comment déclarer ma variable sans quelle ne perturbe le bon fonctionnement ?
j'ai l'impression d'avancer mais ma connaissance est limitée ça fait deux semaines que j'ai commencer à apprendre l'arduino et j'y connait absolument rien en programmation ...

Et effectivement dans ton cas, ta variable etatBouton ne sert strictement à rien.
J'ai dit précédemment qu'il n'y avait pas de souci avec la variable interrupteur, mais en relisant ton code, je m'aperçois que sa déclaration pose aussi problème :oops:. Car tu perds également le contenu de interrupteur qui est nécessaire pour déterminer l'état de ta led lors de l'appui sur le bouton.

Pour garder le contenu d'une variable en dehors d'une fonction, il n'y a qu'une seule manière : déclarer la variable comme étant une variable globale (dans ton cas boutonPin et ledPin sont des variables globales).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 const int boutonPin = 2; //pin pour le bouton const int ledPin = 13; //pin pour la lED bool inter = LOW;//valeur de l'interrupteur void setup() { Serial.begin(9600); // Initialisation de la LED en sortie pinMode(ledPin, OUTPUT); // Initialisation du bouton en entrée pinMode(boutonPin, INPUT); } void loop() { interrupteur() Serial.println(inter); } void interrupteur() { int boutonState = 0;//Dernier etat du bouton // Lecture de l'état du bouton boutonState = digitalRead(boutonPin); if (boutonState == HIGH) { //si il y a un changement d'état // on change l'état du bouton inter=!inter; } }

Merci de ton retour au final voici mon code revu dans les appelation pour plus de clarté.
J'avais fini par oublier pourquoi mon else était présent a cause du mauvais choix du nom de la variable.
En effet avec ton code si la personne reste un petit trop longtemp appuyé sur le bouton la boucle a le temps de faire plusieurs fois et donc d'allumer et éteindre la LED avant même que nos yeux détecte le changement . le else permet sauter la sécurité car je lactive en fin du if !:)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
const int boutonPin = 2;    //pin pour le bouton
const int ledPin =  13;     //pin pour la lED
 
int inter = LOW;//valeur de l'interrupteur
int antiloop = 0; 
 
void setup() 
{
  Serial.begin(9600);
  // Initialisation de la LED en sortie
  pinMode(ledPin, OUTPUT);     
  // Initialisation du bouton en entrée
  pinMode(boutonPin, INPUT);   
}
 
void loop()
{
	interrupteur();
	Serial.println(inter);
}
 
void interrupteur() {  
    int boutonEtat = 0; 
    // Lecture de l'état du bouton
    boutonEtat = digitalRead(boutonPin);
    //si le bouton est pressé Et antiloop désactivé
    if (boutonEtat == HIGH) && (antiloop == 0)
    {    
      // L'intérupteur change d'état
       inter=!inter;
       digitalWrite (ledPin,HIGH);
      // on active antiloop 
      antiloop=1; // permet de faire échouer le test suivant
    }  
    else 
    {
      // si le test échoue on désactive L'antiloop.
      antiloop=0;
    }
}

19/12/2019, 16h56
Auteur

Le phénomène que tu décris est connu : ce sont des rebonds. Lorsque tu bascules l'interrupteur de On vers Off ou inversement, le contact n'est pas immédiat.
http://electronique71.com/theories-r...-anti-rebonds/
Un des moyens de l'éliminer est d'ajouter une temporisation courte (le phénomène est bref) delay(50) ou, comme tu l'as fait, d'ajouter des tests.