Bouton Poussoir

Bonjour a tous,

Je débute et j’avais une question toute bête a laquelle je ne trouve pas de réponses claires…

Voila mon soucis :

J’ai une variable X
Si j’appui une fois sur le bouton poussoir et que je relache, je voudrais que ca compte (X+1)

Le problème est que je suis dans le LOOP donc quand je veux l’afficher dans le port série ca me marque 11111111111 et non 1 vu que la boucle se repète a l’infini.

Je ne vois pas trop comment faire …

Merci de votre aide :slight_smile:

il faut memorise la valeure que tu viens d'envoyer dans une autre variable
et avant d'envoyer sur le serial tester si x est différent de cette variable

const int bouton = 2; // entrée du bouton en 2
const int led = 3; // sortie LED en 3
int etatBouton; // état du bouton
int X; // X correspond a la variable morse
int Y; // Y vaut 0 ou 1

void setup()
{
pinMode(led, OUTPUT); // LED est une sortie
pinMode(bouton, INPUT); // bouton est une entrée
etatBouton = HIGH; // etat bouton a la base
X = 0; // X prend la valeur 0 au début
Y = 0;
Serial.begin(9600); /// initiation communication port série
}

void loop()
{
etatBouton = digitalRead(bouton); // lecture de l'état du bouton

if(etatBouton == LOW) // si bouton appuyé
{
digitalWrite(led,HIGH); // LED allumée
Y=1; // si bouton enclenché : Y = 1
}

else
{
digitalWrite(led,LOW); // si bouton relaché LED eteinte
Y=0; // Si bouton éteint : Y=0
}
if (Y = 1)
{
X = X+1;
}
if (Y = 0)
{
X = X;
}
Serial.print(X);

}

J'ai essayé de coder ça mais cela ne fonctionne pas .. :confused:

bonjour,
1- code entre balise code </>
2-

J’ai essayé de coder ça mais cela ne fonctionne pas … :confused:

mystère et boule de gomme, à nous de deviner ce qui ne fonctionne pas?

Juste un peu d'aide .. s'il vous plait je reste bloqué..

/

const int bouton = 2; // entrée du bouton en 2
const int led = 3; // sortie LED en 3
int etatBouton; // état du bouton
int X; // X correspond a la variable morse
int Y; // Y vaut 0 ou 1

void setup()
{
pinMode(led, OUTPUT); // LED est une sortie
pinMode(bouton, INPUT); // bouton est une entrée
etatBouton = HIGH; // etat bouton a la base
X = 0; // X prend la valeur 0 au début
Y = 0;
Serial.begin(9600); /// initiation communication port série
}

void loop()
{
etatBouton = digitalRead(bouton); // lecture de l'état du bouton

if(etatBouton == LOW) // si bouton appuyé
{
digitalWrite(led,HIGH); // LED allumée
Y=1; // si bouton enclenché : Y = 1
}

else
{
digitalWrite(led,LOW); // si bouton relaché LED eteinte
Y=0; // Si bouton éteint : Y=0
}
if (Y = 1)
{
X = X+1;
}
if (Y = 0)
{
X = X;
}
Serial.print(X);

}

/

const int  buttonPin = 2;    
const int ledPin = 13;       
int buttonPushCounter = 0;  
int buttonState = 0;        
int lastButtonState = 0;    
int X;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  int X = 0;
}


void loop() {
 	buttonState = digitalRead(buttonPin);
  
	if (buttonState != lastButtonState) {
    if (buttonState == HIGH) {
     
      X = 10*X;
      X = X+1;
      
      Serial.println(X, );
}   
 lastButtonState = buttonState;
}
}

J’ai essayé de faire ca mais ca marche ca fais:
1
11
111
1111
11111
(ce que je veux)

mais après ca fait

-19961
-300009
etc …

Quelqu’un sait pourquoi?

merci !

bonjour
je te joins un programme qui allume une del au quatrième appui sur un bp et qui l'éteint au cinquième

const int Bp = 2;
const int Led = 4;
int EtatBp = 0;
int Compteur = 0;
void setup() 
{
Serial.begin(9600);
pinMode ( Led, OUTPUT);
pinMode ( Bp, INPUT);

}

void loop() 
{
EtatBp = digitalRead (Bp);  

if (EtatBp == HIGH)
{
  Compteur ++;
  Serial.println (Compteur,DEC);
}

if (Compteur == 4)
{
  digitalWrite (Led,HIGH);
}

if (Compteur ==5)
{
  digitalWrite(Led,LOW);
  Compteur = 0;
}
delay (500);
}

clemraym:
J'ai essayé de faire ca mais ca marche ca fais:
1
11
111
1111
11111
(ce que je veux)

mais après ca fait

-19961
-300009
etc ...

Quelqu'un sait pourquoi?

merci !

Tu travailles sur un int. Celui-ci ne peut stocker que des valeurs entre -32768 et +32767. lorsque tu multiplies 11111 par 10 le résultat dépasse la capacité de codage de la variable.
Pour t'en convaincre, il suffirait de changer la définition de X pour la passer en unsigned long int. La variable sera stockée sur 32 bits au lieu de 16 et tu pourras faire tourner ta boucle un peu plus longtemps (jusqu'au moment ou tu dépasseras la capacité de codage d'un unsigned long).

Merci beaucoup pour votre aide !!

Essaie de déclarer x comme un "unsigned long" au lieu de int, t'auras jusqu'à 2 puissance 32 de "marge" pour faire des "1".
Par contre si tu veux pouvoir afficher des "1" à l'infini, ce n'est pas vraiment la bonne méthode, il vaut mieux afficher le caractère plutôt que de créer un nombre si grand car t'atteindras toujours une limite puisqu'il y en a toujours une.

Enfin, la gestion de ton bouton est assez sommaire et risque de te réserver des surprises étonnantes ou désagréables si tu ne prends pas en compte un minimum d'anti-rebond. Pour comprendre ce que c'est et comment gérer les boutons poussoir en général (ainsi que tout "contacteur" physique y ressemblant), tu peux lire ce tuto qui est justement dédié à expliquer tout cela.

Sinon, plus généralement, il est très fortement recommandé de lire le tuto d'eskimon pour bien débuter avec ton Arduino.

chriss62 merci pour le programme, mais le problème est que si je maintien le bouton, le vois dans le série que ca défile .. c'est le même problème qu'au début..

Ahhh ! C'est donc ca l'anti-rebond ! Sans anti-rebond il y a des signaux "parasite" c'est sa?

clemraym:
Ahhh ! C'est donc ca l'anti-rebond ! Sans anti-rebond il y a des signaux "parasite" c'est sa?

non, ton problème à toi n'est pas l'anti-rebond, ton problème dans un premier temps, c'est que t'effectues la même action tant que le bouton reste appuyé et pas seulement au moment de la transition. Lis le tuto, tout y est expliqué. S'il y a quelque chose de pas clair, n'hésite pas à poser des questions !

J'ai changé le code j'obtient ca :

#define PIN_ENTREE_BOUTON 8
#define T1 10
#define T2 500
long X;
 
bool boutonAppuye = false;
unsigned long dateAntiRebond = 0;
int compteurDeClicks = 0;
 
void setup()
{
pinMode(PIN_ENTREE_BOUTON, INPUT);
Serial.begin(9600);
X = 0;
}
 
void loop()
{
bool etatSignal = digitalRead(PIN_ENTREE_BOUTON);
 
if ( !etatSignal )
{
if ( dateAntiRebond != 0 )
{
unsigned long tempsEcoule = millis() - dateAntiRebond;
 
if ( tempsEcoule >= T1 )
{
boutonAppuye = true;
dateAntiRebond = 0;
X++;
X = X*10;
Serial.println(X);
}}
  
else if ( !boutonAppuye )
{
dateAntiRebond = millis();
}}

  else
{
if ( boutonAppuye )
{
boutonAppuye = false;
}
else
{
dateAntiRebond = 0;
}}}

Le code doit vraiment être aussi long pour simplement faire 111 etc.. ?

Merci :slight_smile:

votre code pique les yeux tellement il est mal indenté… virez les lignes vides qui ne servent à rien et faites ctrl-T (PC) or cmd-T (Mac) dans l’IDE avant de copier le code pour qu’il soit indenté correctement…

c’est câblé comment ? vous avez une résistance de pullup externe?

si vous voulez faire un peu à la va vite sans pouvoir rien faire tant que le bouton n’est pas relâché, virez la résistance externe, câblez comme cela:

 Pin 8 --> Bouton --> GND

et votre code peut ressembler à cela et fonctionne jusqu’à 4 294 967 295 clicks (232 - 1). ensuite ça repasse à zéro

#define PIN_ENTREE_BOUTON 8
#define antiRebond 15
unsigned long compteurDeClicks = 0;

void setup()
{
  Serial.begin(9600);
  pinMode(PIN_ENTREE_BOUTON, INPUT_PULLUP);
}

void loop()
{
  if (!digitalRead(PIN_ENTREE_BOUTON)) {
    delay(antiRebond); // anti rebond en dur!
    compteurDeClicks++; // compte le nombre de 1 à afficher
    for (unsigned long i = 0; i < compteurDeClicks; i++) Serial.print("1"); Serial.println(); // affiche tous les 1
    while (!digitalRead(PIN_ENTREE_BOUTON)); delay(antiRebond); // attente active de relâchement + anti rebond
  }
}

clemraym:
J'ai changé le code j'obtient ca :
[...]
Le code doit vraiment être aussi long pour simplement faire 111 etc.. ?

Merci :slight_smile:

L'important c'est de comprendre le principe, pas uniquement de faire un copier-coller... :wink:
Comme le dit J-M-L, l'indentation est importante pour que ce soit lisible (formatage selon Mac ou PC comme il l'indique), ensuite une fois le principe compris, on peut le coder de la façon qui nous arrange le mieux et pour le cas précis à traiter.
Donc oui, ca peut être aussi "long" pour traiter un simple appui, mais ca peut l'être encore plus (cf 2e page du tutoriel) ! Ca peut être plus court aussi, comme l'exemple de J-M-L, où le traitement de l'anti-rebond se fait "en dur", ce qui est tout de même déconseillé comme méthode, même si cela fonctionne. La méthode de J-M-L a l'avantage d'être courte et adaptée à un cas aussi simple que le tien, si ton code ne devra jamais faire autre chose qu'afficher des 1...

oui l'attente active et le debounce en dur c'est pas top même si ça fait le job dans la plupart des cas

Bonjour

A quoi sert le ! devant le "digitalRead(Pin_Entree_Bouton ?

Cordialement Chris

Le[b] ![/b] veut dire prendre l'inverse en logique booléenne !0 c'est 1 (true) et !1 c'est 0 (false) (en fait !x si x est non nul c'est 0 (false)).

Par abus comme LOW c'est 0 et HIGH c'est 1, !digitalRead(pin) ça,veut dire si la pin est LOW (parceque si la pin est LOW, !LOW = true et donc le if est validé)

Merci Jml

Par contre je ne comprends pas trop bien comment affiche tous les 1

J ai rajouté à la suite de ton Serial.println(); un Serial.println(compteur_De_Clicks);

Donc la j ai bien 1 2 3 4 5 etc qui s affiche

mais le 1 11 111 1111 11111 je ne comprends pas trop

cordialment chris62