[Resolu]Qu'est ce qui ne va pas dans ce code?

Salut a tous!
Je travaille actuellement sur un code pour incrémenter ou décrémenter un afficheur 7 segments avec 2 boutons.
Quelqu’un saurait me’ dire pourquoi cela ne fonctionne pas? Niveau montage ça doit aller car avec un code “Test” un peu différent j’arrive a allumer et éteindre des leds de l’afficheur avec mémoire de 1 à 4.
Voici le contenu du code qui ne fonctionne pas:
L’afficheur est complètement allumé et rien ne se passe lors de l’appui des boutons

const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;
const int btn_minus = 8;
const int btn_plus = 9;
int chiffre = 0;
int etat_bouton;
int memoire_plus = HIGH;
int memoire_minus = HIGH;

void setup()
{
pinMode(bit_A, OUTPUT);
pinMode(bit_B, OUTPUT);
pinMode(bit_C, OUTPUT);
pinMode(bit_D, OUTPUT);
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);

digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}

void loop()
{
etat_bouton = digitalRead(btn_plus);

if((etat_bouton != memoire_plus) && (etat_bouton == LOW))
{
chiffre++; 
}
memoire_plus = etat_bouton; 
etat_bouton = digitalRead(btn_minus); 
if((etat_bouton != memoire_minus) && (etat_bouton == LOW))
{
chiffre--;
}
memoire_minus = etat_bouton; 
if(chiffre > 4)
{
chiffre = 4;
}
if(chiffre < 0)
{
chiffre = 0;
}

affiche(chiffre);
}
void affiche(int valeur_recue)
{

digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);

if(valeur_recue = 0)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue = 1)
{
digitalWrite(bit_A, HIGH);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue = 2)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, HIGH);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue = 3)
{
digitalWrite(bit_A, HIGH);
digitalWrite(bit_B, HIGH);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue = 4)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, HIGH);
digitalWrite(bit_D, LOW);
}
}

Merci!

Il y a des pullups sur les boutons?

Oui il y en a

Ajoute un Serial.println(etat_bouton); pour voir ce qui se passe.

bonjour,
je dirai que c'est un peu normal, tout est égal dans ton code.
inspire toi de cet exemple
http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ExempleButtonStateChange

Que veux-tu dire par "tout est égal"?
Je débute en elec et c'est un peu compliqué :cold_sweat:

c’est pas de l’électronique là, mais du bon sens :wink:

void loop()
{
[b]etat_bouton = digitalRead(btn_plus);[/b]

if((etat_bouton != memoire_plus) && (etat_bouton == LOW))//ca veut rien dire memoire_plus est HIGH, donc pourquoi meetre etat bouton LOW en plus??????
{
chiffre++; 
}
[b]memoire_plus = etat_bouton; 
etat_bouton = digitalRead(btn_minus); //Y a pas un blem la?[/b]
if((etat_bouton != memoire_minus) && (etat_bouton == LOW))
{
chiffre--;
}
memoire_minus = etat_bouton; 
if(chiffre > 4)
{
chiffre = 4;
}
if(chiffre < 0)
{
chiffre = 0;
}

si bouton_plus=1
donc on incrémente
si compteur>9
donc compteur = 9
si compteur<0
donc compteur = 0
si bouton moins=1
si bouton_plus et bouton_moins = 0
on fait rien

J’ai réussi a faire ce que je voulais c’est bon!
En fait j’ai tout bêtement remplacé les “=” par des “==”

Et j’ai aussi supprimé le bloc dans void loop de remise a 0 car sinon tout était allumé avec différents intensités, il fallait deviner les chiffres…

Voici le programme fonctionnel:

const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;
const int btn_minus = 8;
const int btn_plus = 9;
int chiffre = 0;
int etat_bouton;
int memoire_plus = HIGH;
int memoire_minus = HIGH;

void setup()
{
pinMode(bit_A, OUTPUT);
pinMode(bit_B, OUTPUT);
pinMode(bit_C, OUTPUT);
pinMode(bit_D, OUTPUT);
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);

digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}

void loop()
{
etat_bouton = digitalRead(btn_plus);

if((etat_bouton != memoire_plus) && (etat_bouton == LOW))
{
chiffre++; 
}
memoire_plus = etat_bouton; 
etat_bouton = digitalRead(btn_minus); 
if((etat_bouton != memoire_minus) && (etat_bouton == LOW))
{
chiffre--;
}
memoire_minus = etat_bouton; 
if(chiffre > 4)
{
chiffre = 4;
}
if(chiffre < 0)
{
chiffre = 0;
}

affiche(chiffre);
}
void affiche(int valeur_recue)
{


if(valeur_recue == 0)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue == 1)
{
digitalWrite(bit_A, HIGH);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue == 2)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, HIGH);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue == 3)
{
digitalWrite(bit_A, HIGH);
digitalWrite(bit_B, HIGH);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
if(valeur_recue == 4)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, HIGH);
digitalWrite(bit_D, LOW);
}
}

Merci pour votre aide

infobarquee:
c'est pas de l'électronique là, mais du bon sens :wink:

void loop()

{
etat_bouton = digitalRead(btn_plus);

if((etat_bouton != memoire_plus) && (etat_bouton == LOW))//ca veut rien dire memoire_plus est HIGH, donc pourquoi meetre etat bouton LOW en plus??????
{
chiffre++;
}

@infobarquee je pense que tu devrais te méfier de ton bon sens.
Dans la ligne en question, on teste une transition, si l'état actuel est différent de l'état précédent cela ne présume en rien de l'état du bouton. Donc on ajoute à la condition le test sur etat_bouton =low pour détecter un front descendant.

mémoire_plus est à high parce qu'on suppose qu'au démarrage le bouton est au repos et donc high lui aussi. Ensuite mémoire_plus est mis à jour à chaque passage dans la boucle.

mon bon sens est des plus logique je pense.
si on appuie sur un bouton, il passe de LOW à HIGH, non?
si on le relache, il passe de HIGH à LOW, non?
donc pourquoi se compliquer la vie a vérifier quelque chose qui est “logique” (high ou low) ?
d’ou ma logique plus haut, modifié pour plus de clareté

si bouton_plus=1 => compteur = compteur+1
si bouton_moins=1 => compteur = compteur -1
si bouton_plus et bouton_moins = 0 => on fait rien donc compteur=compteur

si compteur>4
donc compteur =4
si compteur<0
donc compteur = 0
sinon compteur = compteur

infobarquee:
mon bon sens est des plus logique je pense.
si on appuie sur un bouton, il passe de LOW à HIGH, non?
si on le relache, il passe de HIGH à LOW, non?

Déjà là cela dépend du câblage dudit bouton et de son type (normalement ouvert/normalement fermé).
Le programme tel qu’il était présenté donnait plutôt à penser que le bouton était actif à l’état bas.

infobarquee:
donc pourquoi se compliquer la vie a vérifier quelque chose qui est “logique” (high ou low) ?
d’ou ma logique plus haut, modifié pour plus de clareté

si bouton_plus=1 => compteur = compteur+1
si bouton_moins=1 => compteur = compteur -1
si bouton_plus et bouton_moins = 0 => on fait rien donc compteur=compteur

si compteur>4
donc compteur =4
si compteur<0
donc compteur = 0
sinon compteur = compteur

Parce que si on fait ça est que l’on tient le bouton le compteur s’incrémente tout seul.
En prenant en compte l’état précédent du bouton on détecte une transition et donc on ne prend en compte qu’une fois même si le bouton reste appuyé longtemps. A condition bien sur que le bouton ne rebondisse pas trop.

Déjà là cela dépend du câblage dudit bouton et de son type (normalement ouvert/normalement fermé).
Le programme tel qu’il était présenté donnait plutôt à penser que le bouton était actif à l’état bas.

en général, on part du principe que le bouton est NO dans 95% des cas.
mais ca ne change rien au pb.

Parce que si on fait ça est que l’on tient le bouton le compteur s’incrémente tout seul.
En prenant en compte l’état précédent du bouton on détecte une transition et donc on ne prend en compte qu’une fois même si le bouton reste appuyé longtemps. A condition bien sur que le bouton ne rebondisse pas trop.

c’est juste une logique pas un programme complet :wink:
je préfère utiliser la notion de temps (millis) pour définir la durée d’appuie sur le bouton afin de déterminer s’il est toujours “enfoncé” ou non, ca peut éviter aussi les appuies involontaires ou les rebonds possibles.
si temps_mini_appuie < 50 ou temps_maxi_appuie > 200 => on boucle (valeurs mises au pif :wink: )

avec la méthode de transition, s’il y a des rebonds, tout va passer de HIGH à LOW et vis versa en permanence, ce qui peut être critique dans certains cas.
ceci n’est que mon avis perso.

enfin chacun sa méthode, laquelle est la meilleure? je ne saurais le dire.