bonjour
j'allume avec 3 BP une led soit jaune rouge ou verte, en appuyant sur l'un des BP une led s'allume ou s'éteint
en rajoutant un 4 BP j'aimerais comprendre comment éteindre les 3 led d'un coup ou les allumer
voici ce que j'aie réaliser comme sketch
int etatJ=0;
int LJ = 3;
int BTJ = 2;
Question subsidiaire, est-ce-que tes paires boutons/LED sont indépendantes ou sont dépendantes de l'état de la précédente, c'est à dire, je dois allumer la première, pour allumer la 2ème pour allumer la troisième et la même chose pour éteindre?
C'est à peu près correct. J'aurai quelques remarques à faire
tu n'as pas fait de traitement anti rebond
attendre que le bouton soit relâché n'est pas la meilleure méthode de traitement (surtout que sans traitement anti rebond tu risque de sortir sans que le bouton soit relâché). Il vaudrait mieux faire le traitement à l'appui sur le bouton.
plutôt que de gérer des variables etat tu peux relire l'état de la sortie.
au lieu de faire 3 fois le même traitement tu aurais pu faire une boucle.
Un dernier point: le nom des variables (et des variables qui auraient du être des constantes) laisse vraiment à désirer.
Voilà, j'ai un peu "détricoté" tes if.
Tu te rendra compte que c'est devenu tout des boîtes indépendantes et identiques sauf la boîte qui fait tout, la prochaine étape serait de mettre tout ça en tableau ou une fonction.
Comme dit @kamill, il faudrait un anti-rebonds, regardes du côté de la librairie Arduino. La boucle d'attente du relâchement de la touche while(digitalRead(BTR) == boutonEtatPresse); fait une partie de l'anti-rebond mais pas tout. Avec cette attente du relâchement de la touche, son action se fait qu'une fois la touche relâchée.
Une remarque concernant ton schéma, tu as mis le +5V comme commun de tes boutons, ce qui oblige de mettre des résistances PULL_DOWN. Il est beaucoup plus pratiquer de faire l'inverse, c'est à dire, le GND comme commun, ainsi tu peux initialiser tes boutons pinMode(BTJ, INPUT_PULLUP); et bénéficier des résistances internes de l'Arduino. La lecture de l'état pressé se fera par un 0 par if(digitalRead(BTJ)== 0). L'avantage de ce type de montage est que tu n'as pas de potentiel à amener aux boutons, que le GND et ça on en a de toute façon partout. Je t'ai mis une variable, boutonEtatPresse, qui gère l'état lu en fonction du type de montage.
int etatJ=0;
int LJ = 3;
int BTJ = 2;
int etatR=0;
int LR = 5;
int BTR = 4;
int etatV=0;
int LV = 7;
int BTV = 6;
int etatT=0;
int ETT = 0;
int BTT = 8;
//int LT =LJ +LV +LR;
#define boutonEtatPresse 1 // Etat lu quand un bouton est pressé
void setup()
{
pinMode(LJ, OUTPUT);
pinMode(BTJ, INPUT);
pinMode(LR, OUTPUT);
pinMode(BTR, INPUT);
pinMode(LV, OUTPUT);
pinMode(BTV, INPUT);
pinMode(BTT, INPUT);
}
void loop() {
if(digitalRead(BTJ)== boutonEtatPresse)
{
if(etatJ==0) etatJ=1;
else etatJ=0;
while(digitalRead(BTJ) == boutonEtatPresse);
}
digitalWrite(LJ,etatJ);
if(digitalRead(BTR)== boutonEtatPresse)
{
if(etatR==0) etatR=1;
else etatR=0;
while(digitalRead(BTR) == boutonEtatPresse);
}
digitalWrite(LR,etatR);
if(digitalRead(BTV)== boutonEtatPresse)
{
if(etatV==0) etatV=1;
else etatV=0;
while(digitalRead(BTV) == boutonEtatPresse);
}
digitalWrite(LV,etatV);
if(digitalRead(BTT) == boutonEtatPresse)
{
if(etatT==0) etatT=1;
else etatT=0;
etatJ = etatT;
etatR = etatT;
etatV = etatT;
while(digitalRead(BTT) == boutonEtatPresse);
}
}
Je te laisses regarder les différences entre nos 2 versions et poser les bonnes querstions.
Merci de tes commentaires et remarques je vais étudier ton sketch afin de comprendre la finalité et ne plus refaire les même erreurs, j avais lu divers infos sur l anti rebond du BP et la je pensais qu il n y avait l utilité
Pourquoi pinMode(BTJ, INPUT_PULLUP);
Et pas les autres qu'elle est sa fonctionnalité
Designe comm Entree en utilisant la résistance pushpull?
Bjr et merci cela fonctionne très bien
il me reste a modifier le schéma pour travailler sur l'anti rebond , plutôt utiliser Gnd que Vcc et comprendre la fonction #define
je posterai le schema final
Celle des programmeurs qui n'aiment pas ajouter des composants.
Celle des électroniciens qui n'aiment pas écrire des lignes de code dont on peut se passer.
La première école consiste, en très gros, à faire une boucle d'attente pour laisser passer les rebonds.
La deuxième école consiste à ajouter un condensateur en parallèle sur le contact pour empêcher que les rebonds soient visibles par l'entrée du microcontrôleur.
La première école retarde la disponibilité de l'information.
La seconde école donne le résultat immédiatement.
Si tu as un bouton pourri :
Avec la première école, il faut augmenter le retard -> cela peut être géré automatiquement par le code.
Avec la seconde école, il faut augmenter la valeur soit de la résistance, soit du condensateur. Le retard est toujours inexistant.
Principe du condensateur :
Au repos le condensateur se charge au travers de la résistance de pull-up.
Quand on appuie sur le bouton le condensateur est immédiatement déchargé. L'entrée du microcontrôleur voit un état bas.
Pendant le rebond le contact s'ouvre et le condensateur se recharge au travers la résistance de pull-up. Cette recharge est plus lente que la fréquence du rebond et le condensateur est de nouveau déchargé avant que la tension à ses bornes atteigne le seuil de détection d'un niveau Haut.
Avec un bouton mis à la masse et la résistance interne de "pull-up" un simple condensateur de 100 nF suffit (valeur passe partout qu'il faut avoir dans son tiroir).
En tant qu'électronicien bien évidement je place un condensateur, mais tu noteras que je cite les deux écoles pour laisser le choix au demandeur.
A toi de choisir la méthode qui te convient le mieux.
Merci pour ces infos et n étant programmeur je vais choisir le condo d apres tes infos et ma compréhensions le tps de réponse est plus rapide avec le condo
Cordialement
Non la réponse est plus rapide sans condo (puisqu'il n'y a pas de condo a décharger).
Mais ça n'a vraiment aucune importance. On parle la d'un bouton actionné par un humain et non par superman et que ça mette une ms de plus ou de moins pour détecter l'enfoncement, on s'en tamponne le coquillard.
Non : 100 nF qui se déchargent dans 0,1 ohms ce ne peut pas être plus long que des rebonds qui ont lieu pendant plusieurs millisecondes.
Je n'ai pas fait un sujet polémique, mais factuel.
Je ne cherche pas à n'indiquer qu'une seule méthode, je laisse le choix.
Je n'oublie pas d'indiquer celle que je ne pratique pas.
J'ajoute que sur les cartes microcontrôleurs, c'est la solution du condensateur qui est utilisé.
Je complète en ajoutant que des impulsions de Vcc qui se propagent créént des perturbations électromagnétiques.
Alors oui le niveau des perturbations est négligeable, alors oui les quelques dizaines de ms de retard sont rarement gênantes.
Alors oui autant connaître ces inconvénients pour faire ses choix et pour les cas rarissimes où ces perturbations deviendraient gênantes.
Avec un traitement anti-rebond bien foutu le changement d'état est pris en compte immédiatement (hors délai de lecture qui est le même dans les deux cas).
C'est après la prise en compte qu'il y a un délai de quelques ms pour la prise en compte du changement d'état suivant.
Peu importe, quand il y a deux solutions une matérielle et l'autre logicielle ma conception de l'aide est de pas passer systématiquement sous silence celle que personnellement je n'utilise pas et de ne pas la dénigrer.
Si le demandeur veut faire un antirebond logiciel cela ne me gênera pas, il aura fait son choix en ayant été éclairé.
Je suis pour la bibliothèque, parce que elle évite le condensateur, il n'est pas nécessaire de fouiller dans les tiroirs pour en trouver et, surtout, une bibliothèque offre des services supplémentaires que n'offre pas un condensateur comme la bibliothèque Button-Master qui offre toute une palette d'évènements.
