Bonsoir à tous,
Je me suis lancé dans le arduino aujourd'hui et j'ai fait 2 petits scripts (allumer une led et l'allumer avec un bouton poussoir). J'ai décidé d'essayer d'écrire un petit code moi même. quand j'appuie sur le bouton la led se met à clignoter quand je rappuie elle arrête. Voici mon code :
const int bouton = 4; // la broche 4 devient bouton
const int led = 12; // la broche 12 devient led
int etatbouton; // variable qui enregistre l'état du bouton
bool allumee;
void setup()
{
pinMode(bouton, INPUT); // Initialise le bouton comme entrée
pinMode(led, OUTPUT); // Initialise la led comme sortie
etatbouton = LOW; // Initialise l'état du bouton comme relâché
allumee = false;
}
void loop()
{
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = true;
}
while (allumee = true)
{
digitalWrite(led,LOW);
delay(200);
digitalWrite(led,HIGH);
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = false;
}
}
}
Ma led ne fait que clignoter peut importe ce que je fais. Quel est le problème ?
sitôt que etatbouton == HIGH est vrai, on sort de cette boucle, pour se trouver avec le bouton toujours pressé (parce qu'on n'est pas assez rapide à le relâcher) dans:
Une fois que tu as maîtrisé la lecture des boutons, tu peux te simplifier la vie en utilisant la bibliothèque ezButton, par exemple, il y en a beaucoup d'autres.
J'ai compris ce que tu voulais dire mais je pense mal l'avoir appliqué. Voici le code réécris
const int bouton = 4; // la broche 4 devient bouton
const int led = 12; // la broche 12 devient led
int etatbouton; // variable qui enregistre l'état du bouton
bool allumee;
void setup()
{
pinMode(bouton, INPUT); // Initialise le bouton comme entrée
pinMode(led, OUTPUT); // Initialise la led comme sortie
etatbouton = LOW; // Initialise l'état du bouton comme relâché
allumee = false;
}
void loop()
{
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = true;
while (etatbouton == HIGH)
{
etatbouton = digitalRead(bouton);
}
}
while (allumee == true)
{
digitalWrite(led,HIGH);
delay(200);
digitalWrite(led,LOW);
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = false;
while (etatbouton == HIGH)
{
etatbouton = digitalRead(bouton);
}
}
}
}
Le problème c'est que maintenant la led ne clignote plus elle s'allume quand j'appuie sur le bouton et s'éteint quand je rappuie dessus.
Je remarque que l'indentation afficher par le forum n'est pas la même que celle que j'ai sur arduino ide
Chez moi, ta version fonctionne très bien.
As-tu une résistance de PULL_DOWN sur la pin (4) de ton bouton?
Si le PULL_DOWN n'est pas une oblogation pour toi, la "technique" du PULL_UP est plus pratique, il faut simplement mettre ton bouton au GND à la place du +5V et tu bénéficies d'une résistance de PULL_UP interne à l'Arduino en initialisant la pin par pinMode(bouton, INPUT_PULLUP); // Initialise le bouton comme entrée
et le bouton pressé donne: if(etatbouton == LOW)
en résumé, ton bouton, pressé donne LOW à la place de HIGH.
Cette façon de faire a l'avantage qu'il ne faut amener qu'un GND aux divers boutons et autre commutateurs, à la place d'un potentiel, 5 volts en l'occurrence.
Souvent, on construit le code en fonction du montage, ainsi dans ton cas qui est la lecture d'un bouton, on peut soit utiliser la technique PULLDOWN (Tirer vers le bas) que tu emploies:
et pour initialiser cette entrée on utilisera: pinMode(bouton, INPUT); // Initialise le bouton comme entrée
le bouton étant câblé d'un côté au +5V et lu comme actif:
soit la technique PULLUP (mas préférée )
et pour initialiser cette entrée on utilisera: pinMode(bouton, INPUT_PULLUP); // Initialise le bouton comme entrée
le bouton étant câblé d'un côté au GND et lu comme actif:
Il est à noter que, dans ce cas, (INPUT_PULLUP) la résistance externe n'est pas nécessaire, elle sert dans le cas où le montage est dans un environnement dit perturbé. Cette résistance externe vient en parallèle à celle interne.
On peut se passer de la résistance interne et travailler en PULLUP, en mettant une résistance externe et en initialisant le port: pinMode(bouton, INPUT); // Initialise le bouton comme entrée
Tu vois là, l'influence du montage sur la programmation.
Les images ci-dessus sont prises sur le site Locoduino qui est une excellente source de renseignement concernant l'Arduino.
PS: Cette résistance n'est pas nécessaire:
Tu peux câbler la pin du bouton directement sur celle de l'Arduino.
Puisque tu fais un digitalread, tu demande à ton Arduino dire lire la tension de ton montage électronique.
Et comme tu agis en fonction de cette tension lue, celui-ci influence ton code.
De même la construction des boutons, fait que celui-ci produit des rebonds, c'est à dire que si tu lis rapidement l'état de ta broche, tu pourrais voir plusieurs appuis sur ton boutons, alors que tu en as fait qu'un seul.
Je fais face à un phénomène très bizarre. Ma led reste allumé sans clignoter et quand j'approche ma main de le résistance elle clignote à la fréquence du programme. Le bouton poussoir ne change rien et je n'ai pas toucher au code corrigé. Comment ça se fait que la proximité de ma main change quelque chose ?
J'aimerais aussi savoir comment utilisé le debugger d'arduino ide 2.0 sachant que je suis sur une arduino mega 2560.
On ne peut pas dire qu'une variation de tension puisse influencer le code puisque celui-ci est écrit et téléchargé dans l'Arduino,
Une tension lue peut influencer la ou les réaction(s) du code.
D'accord mais comment le corriger dans ce cas ? Je ne vois pas de fil en l'air donc je pense en effet que c'est une mauvaise masse. Mais du coup mon programme ne marche toujours pas . Et j'aimerais bien savoir comment debugger avec l'ide arduino 2.0 car quand je vais sur le bouton debuggage il me dit que ce n'est pas compatible avec une carte mega.
En effet je n'ai plus de pouvoir surnaturel maintenant haha. Quand je charge le programme ma led s'allume quand j'appuie sur le bouton elle clignote et quand je rappuie elle se re-allume. Parfois quand j'appuie il ne se passe rien ça arrive aussi. J'imagine donc que mon montage est maintenant correct et que le problème vient du code voici donc le code :
const int bouton = 4; // la broche 4 devient bouton
const int led = 12; // la broche 12 devient led
int etatbouton; // variable qui enregistre l'état du bouton
bool allumee;
void setup()
{
pinMode(bouton, INPUT); // Initialise le bouton comme entrée
pinMode(led, OUTPUT); // Initialise la led comme sortie
etatbouton = LOW; // Initialise l'état du bouton comme relâché
allumee = false;
}
void loop()
{
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = true;
while (etatbouton == HIGH)
{
etatbouton = digitalRead(bouton);
}
}
while (allumee == true)
{
digitalWrite(led,HIGH);
delay(500);
digitalWrite(led,LOW);
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = false;
digitalWrite(led,LOW);
while (etatbouton == HIGH)
{
etatbouton = digitalRead(bouton);
}
}
}
}
Comment utilisé le debugger pour que je puisse être un peu plus autonome dans le gestion des bugs de mon code ?
D'accord merci infiniment pour ton aide précieuse J'ai une dernière requête si vous avez le temps. J'aimerais savoir ce qui cloche dans mon programme pour que ma led clignote quand j'appuie sur le bouton et arrête de clignoter quand je rappuie dessus. Aussi je veux savoir si sans debugger ce n'est pas trop pénible de coder ? Je sais que quand je codais en python je ne pouvais pas m'en passer. Et comment faire pour voir comment le code s'exécute dans la puce ?
J'ai copié/collé ton programme dans mon éditeur et il fonctionne sans problème.
Je ne suis pas un pro de la programmation, loin s'en faut, je ne peut pas te répondre. Personnellement, je tape mon programme, le démarre et s'il y a des problèmes je mets des Serial.println où je soupçonne le problème quitte à les supprimer une fois le programme au point.
Autrement, mes outils essentiels sont la sonde logique
et l'oscilloscope
Je te mets ton programme avec des Serial.println console à 115200.
const int bouton = 4; // la broche 4 devient bouton
const int led = 12; // la broche 12 devient led
int etatbouton; // variable qui enregistre l'état du bouton
bool allumee;
void setup()
{
Serial.begin(115200);
pinMode(bouton, INPUT); // Initialise le bouton comme entrée
pinMode(led, OUTPUT); // Initialise la led comme sortie
etatbouton = LOW; // Initialise l'état du bouton comme relâché
allumee = false;
}
void loop()
{
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = true;
Serial.println("Allume");
while (etatbouton == HIGH)
{
etatbouton = digitalRead(bouton);
}
Serial.println("Bouton Allume relache");
}
while (allumee == true)
{
digitalWrite(led,HIGH);
delay(500);
digitalWrite(led,LOW);
etatbouton = digitalRead(bouton);
if(etatbouton == HIGH)
{
allumee = false;
digitalWrite(led,LOW);
Serial.println("Etaint");
while (etatbouton == HIGH)
{
etatbouton = digitalRead(bouton);
}
Serial.println("Bouton Eteint relache");
}
}
}
A titre de comparaison, je te montre ton programme avec la bibliothèque JC_Button. J'ai choisi cette bibliothèque parce qu'elle permet de travailler en mode PULLDOWN.
#include <JC_Button.h> // https://github.com/JChristensen/JC_Button
const int bouton = 4; // la broche 4 devient bouton
const int led = 12; // la broche 12 devient led
int etatbouton; // variable qui enregistre l'état du bouton
bool allumee;
Button monBouton(bouton, 20, false, true); // Button(pin, dbTime, puEnable, invert);
void setup()
{
Serial.begin(115200);
monBouton.begin(); // initialize the button object
pinMode(led, OUTPUT); // Initialise la led comme sortie
etatbouton = LOW; // Initialise l'état du bouton comme relâché
allumee = false;
}
void loop()
{
monBouton.read(); // read the button
if (monBouton.wasReleased()) // Si le bouton a été pressé
{
allumee = (allumee == true) ? false : true; // Si déjà allumé, éteindre
Serial.print("LED ");
Serial.println((allumee == true) ? "allumee" : "eteinte");
}
if (allumee)
{
digitalWrite(led,HIGH);
delay(500);
digitalWrite(led,LOW);
delay(100);
}
}
Bonjour @jpbbricole
j'avoue que je n'ai pas trop compris ce que tu veux dire. si la tension varie de 0 à 5V, je ne vois pas trop comment cela ne peut pas influencer ton programme.
J'ai l'impression que l'on à deux façon différente de dire la même chose
)
... Voici le nouveau montage :
J'ai une dernière requête si vous avez le temps. J'aimerais savoir ce qui cloche dans mon programme pour que ma led clignote quand j'appuie sur le bouton et arrête de clignoter quand je rappuie dessus. Aussi je veux savoir si sans debugger ce n'est pas trop pénible de coder ? Je sais que quand je codais en python je ne pouvais pas m'en passer. Et comment faire pour voir comment le code s'exécute dans la puce ?
