j'aurai besoin de quelque lumière de personne qui s'y connaissent mieux que moi =p
J'ai eu comme projet de domotique au lycée , avec une carte arduino, de faire de la gestion d'éclairage.
Principe:
- bp
-une carte arduino
-un relais
-une lampe
-deux led
-L'appuis normal sur le bp allume la lampe pendant un temps donné ( comme une lumière normale)
-programation du temps donné:
Un appuis Supérieur ou égale à 2s programme le temps d'allumage de la lampe de 5 min
un appuis supérieur ou égale à 5s programme le temps d'allumage de la lampe de 10 min
deux led temoin (une pour 5 min , la deuxieme pour 10min)
Mon problème est :
je n'arrive pas à compter le temp a partir de l'appuis sur le bp,
car après selon le temp mesurer je stock dans des variables le temp d'allumage de la lampe,
de plus y aurai-t-il un autre moyen de laisser allumer la lampe pendant un certain temps sans utiliser la fonction delay, car celle-ci stop le programme ,qui ceci n'est pas génial =s
merci pour ta réponse,
j'ai trouver ce code la,
il marche pas de soucis, mais je ne le comprend pas , qqun pourrait-il me l'expliquer ?
/* 4-Way Button: Click, Double-Click, Press+Hold, and Press+Long-Hold Test Sketch
By Jeff Saltzman
Oct. 13, 2009
To keep a physical interface as simple as possible, this sketch demonstrates generating four output events from a single push-button.
1) Click: rapid press and release
2) Double-Click: two clicks in quick succession
3) Press and Hold: holding the button down
4) Long Press and Hold: holding the button down for a long time
*/
#define buttonPin 7 // analog input pin to use as a digital input
#define ledPin1 9 // digital output pin for LED 1
#define ledPin2 10 // digital output pin for LED 2
#define ledPin3 11 // digital output pin for LED 3
#define ledPin4 12 // digital output pin for LED 4
// LED variables
boolean ledVal1 = false; // state of LED 1
boolean ledVal2 = false; // state of LED 2
boolean ledVal3 = false; // state of LED 3
boolean ledVal4 = false; // state of LED 4
//=================================================
void setup()
{
// Set button input pin
pinMode(buttonPin, INPUT);
digitalWrite(buttonPin, HIGH );
// Set LED output pins
pinMode(ledPin1, OUTPUT);
digitalWrite(ledPin1, ledVal1);
pinMode(ledPin2, OUTPUT);
digitalWrite(ledPin2, ledVal2);
pinMode(ledPin3, OUTPUT);
digitalWrite(ledPin3, ledVal3);
pinMode(ledPin4, OUTPUT);
digitalWrite(ledPin4, ledVal4);
}
void loop()
{
// Get button event and act accordingly
int b = checkButton();
if (b == 1) clickEvent();
if (b == 2) doubleClickEvent();
if (b == 3) holdEvent();
if (b == 4) longHoldEvent();
}
//=================================================
// Events to trigger by click and press+hold
void clickEvent()
{
ledVal1 = !ledVal1;
digitalWrite(ledPin1, ledVal1);
}
void doubleClickEvent()
{
ledVal2 = !ledVal2;
digitalWrite(ledPin2, ledVal2);
}
void holdEvent()
{
ledVal3 = !ledVal3;
digitalWrite(ledPin3, ledVal3);
}
void longHoldEvent()
{
ledVal4 = !ledVal4;
digitalWrite(ledPin4, ledVal4);
}
/*
MULTI-CLICK: One Button, Multiple Events
Oct 12, 2009
Run checkButton() to retrieve a button event:
Click
Double-Click
Hold
Long Hold
*/
// Button timing variables
int debounce = 20; // ms debounce period to prevent flickering when pressing or releasing the button
int DCgap = 250; // max ms between clicks for a double click event
int holdTime = 2000; // ms hold period: how long to wait for press+hold event
int longHoldTime = 5000; // ms long hold period: how long to wait for press+hold event
// Other button variables
boolean buttonVal = HIGH; // value read from button
boolean buttonLast = HIGH; // buffered value of the button's previous state
boolean DCwaiting = false; // whether we're waiting for a double click (down)
boolean DConUp = false; // whether to register a double click on next release, or whether to wait and click
boolean singleOK = true; // whether it's OK to do a single click
long downTime = -1; // time the button was pressed down
long upTime = -1; // time the button was released
boolean ignoreUp = false; // whether to ignore the button release because the click+hold was triggered
boolean waitForUp = false; // when held, whether to wait for the up event
boolean holdEventPast = false; // whether or not the hold event happened already
boolean longHoldEventPast = false;// whether or not the long hold event happened already
int checkButton()
{
int event = 0;
// Read the state of the button
buttonVal = digitalRead(buttonPin);
// Button pressed down
if (buttonVal == LOW && buttonLast == HIGH && (millis() - upTime) > debounce)
{
downTime = millis();
ignoreUp = false;
waitForUp = false;
singleOK = true;
holdEventPast = false;
longHoldEventPast = false;
if ((millis()-upTime) < DCgap && DConUp == false && DCwaiting == true) DConUp = true;
else DConUp = false;
DCwaiting = false;
}
// Button released
else if (buttonVal == HIGH && buttonLast == LOW && (millis() - downTime) > debounce)
{
if (not ignoreUp)
{
upTime = millis();
if (DConUp == false) DCwaiting = true;
else
{
event = 2;
DConUp = false;
DCwaiting = false;
singleOK = false;
}
}
}
// Test for normal click event: DCgap expired
if ( buttonVal == HIGH && (millis()-upTime) >= DCgap && DCwaiting == true && DConUp == false && singleOK == true)
{
event = 1;
DCwaiting = false;
}
// Test for hold
if (buttonVal == LOW && (millis() - downTime) >= holdTime)
{
// Trigger "normal" hold
if (not holdEventPast)
{
event = 3;
waitForUp = true;
ignoreUp = true;
DConUp = false;
DCwaiting = false;
//downTime = millis();
holdEventPast = true;
}
// Trigger "long" hold
if ((millis() - downTime) >= longHoldTime)
{
if (not longHoldEventPast)
{
event = 4;
longHoldEventPast = true;
}
}
}
buttonLast = buttonVal;
return event;
}
Le code est assez simple (même si je ne l'aurais pas écrit comme ça). Il suffit de lire les commentaires :
en boucle (dans loop donc)
on lit l'état du bouton.// Read the state of the button
si il est pressé, on note l'instant de début de la pression // Button pressed down
si il est relaché, on regarde si c'était le second clic, et si oui on renvoie un double clic (si non, on sauvegarde juste la date de relachement) // Button released
si le bouton ne change pas d'état, on regarde plusieurs cas :
il n'était enfoncé, qu'il y avait eu un clic, et qu'il est trop tard pour un double clic, on signale un simple clic // Test for normal click event: DCgap expired
si il était enfoncé depuis longtemps, on renvoit un appui long // Trigger "normal" hold
si il était enfoncé depuis très longtemps, on renvoit un appui très long.// Trigger "long" hold
dans tous les autres cas, on ne renvoit pas d'event.
Encore une fois c'est une implémentation qui utilise énormément de variables (11, pour une fonctionnalité somme toute assez simple), c'est autant de risques d'oublier d'en réinitialiser une à un moment, mais, à priori, ce code a été débuggé.
Je vous remercie beaucoup pour cette explication ,
y aurai-t-il un moyen de faire plus simple?
car ce programme sera expliquer a des secondes,
et si déja mois etudiant en bts je m'y retrouve pas =s
( il faut dire que je débute aussi )
car mon but serait de faire en sorte de:
-appuis long : valeur du temps d'allumage (10 min)
-appuis court: valeur du temps d'allumage (5min)
-appuis simple: allumage lampe
J'aurai fait ça avec une interruption sur changement d'état
en passant par 2 variables "flag"
parce que l'on ne peut pas utiliser millis dans une interruption
d'après mes souvenirs.
Pour être une explicite:
void interruption_sur_changement_de_frond() {
if bouton appuye
flag_appuye = true
if bouton_relacher
flag_relacher = true
}
void loop(){
if flag_appuye = true
flag_appuye = false
memorisationA de millis
if flag_relacher = true
flag_relacher = false
memorisationR de millis
comparaison des temps
choix
}
D'aussi loin que je me souvienne (la flemme de vérifier), on peut utiliser millis() dans les interruptions (qui ne fait que retourner le nombre de millisecondes écoulé depuis le démarrage) mais on ne peut pas utiliser delay en revanche (et ça j'en suis sur)
merci pour ces réponse elles m'ont beaucoup aidés merci^^
mais juste une question, tant que je reste appuyer, flag_appuyer est bien égale à false ?
car si je comprend bien la carte lit le programme depuis le début, donc si il relit :
if bouton appuye
flag_appuye = true
alors la variable sera de nouveau vrai ,meme si je reste appuyer sur le bouton ? corigé moi si cela est faux
Mais comme l'a fait remarqué Eskimon on pourrais écrire:
void interruption_sur_changement_de_frond() { //appelé quand le bouton CHANGE d'état
if digitalRead(btn) { // au Moment ou on appui sur le bouton
memorisationA de millis()
}
else { // // au Moment ou on relâche le bouton
memorisationR de millis()
comparaison_des_temps()
}
}
void loop(){
}
merci , tu as répondu a ma question, la solution ci-dessus me parrait la plus simple , au début je me bornai sur la fonction delay, qui n'est pas un très bonne chose, car celle-ci arrete la carte, enfin bref , merci a tous de m'avoir aidé
Arduino,Gestion d'éclairage
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Retrouvez moi sur mon blog et ma chaine Youtube !
Retrouvez moi sur mon blog et ma chaine Youtube !
Retrouvez moi sur mon blog et ma chaine Youtube !