Activer deux relais pour un cycle avec un bouton poussoir

**Skarabee1969** · 27/11/2021, 21h51

Bonjour à toutes et à tous,

J'ai un projet concernant un diorama avec quelques animations et l'utilisation de l'Arduino me semble appropriée et dans mon cas l'encombrement me fera utiliser la version nano.

Le hic c'est que je n'y connais rien, j'ai compris comment téléverser, mais niveau programmation je suis au niveau -1.

Mon projet est le suivant, lorsque j'actionne un bouton poussoir l'Arduino doit activer 2 relais, le relais 1 doit rester actif pendant 1 seconde et le relais 2 dois en même temps rester actif pendant 5 secondes puis les 2 relais doivent s’arrêter jusqu’à ce que j’appuie de nouveau pour faire un autre cycle et ainsi de suite.

J'ai compris qu'il fallait mettre un condensateur + une résistance (physique ou interne a l'Arduino) pour éviter les rebonds.

Pouvez-vous m'aider s'il vous plaît.

D'avance merci

**Jay M** · 28/11/2021, 12h14

Mon projet est le suivant, lorsque j'actionne un bouton poussoir l'Arduino doit activer 2 relais, le relais 1 doit rester actif pendant 1 seconde et le relais 2 dois en même temps rester actif pendant 5 secondes puis les 2 relais doivent s’arrêter jusqu’à ce que j’appuie de nouveau pour faire un autre cycle et ainsi de suite.

en gros vous mettez votre bouton en INPUT_PULLUP (voir la doc) et dans la loop vous faites

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void loop() {
  if (digitalRead(pinBouton) == LOW) { // appui
    digitalWrite(pinRelai1, LOW); // activation relai #1 (en supposant qu'il est actif au niveau bas)
    digitalWrite(pinRelai2, LOW); // activation relai #2 (en supposant qu'il est actif au niveau bas)
    delay(1000); // attente de 1s
    digitalWrite(pinRelai1, HIGH); // désactivation relai #1
    delay(4000); // attente de 4s
    digitalWrite(pinRelai2, HIGH); // désactivation relai #2
    while(digitalRead(pinBouton) == LOW); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
  }
}

je vous laisse bosser un peu pour la déclaration des variables et le setup()

**Skarabee1969** · 28/11/2021, 13h38

Bonjour Jay M,

Merci beaucoup de votre aide

, en inversant les états HIGH et Low pour les relais j'ai presque ce que je recherche.
Presque parce que lorsque j'alimente l'arduino ce dernier me lance un cycle que je ne veux pas, j'ai peut-être mal déclaré des variables.
Pour le bouton-poussoir j'ai placé une résistance de 10K et un condensateur de 10nF

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
 
le bouton poussoir est connecté au pin 2 avec une résistance pull-down de 10KΩ
 
les LED sont connectées au pins 4 et 6 avec des résistances de 220Ω
 
*/
 
//déclaration des variables
 
int pinBouton;
int pinRelai1, pinRelai2;
 
void setup() {   //initialisation des variables
 
pinBouton = 2;
pinRelai1 = 3;
pinRelai2 = 4;
 
//définition des modes
 
pinMode(pinBouton, INPUT); //mode lecture pour le bouton
pinMode(pinRelai1, OUTPUT); //mode écriture pour led1
pinMode(pinRelai2, OUTPUT); //mode écriture pour led2
 
}
 
void loop() {
  if (digitalRead(pinBouton) == LOW) { // appui
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau bas)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau bas)
    delay(1000); // attente de 1s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(4000); // attente de 4s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
    while(digitalRead(pinBouton) == LOW); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
  }
}

**Jay M** · 28/11/2021, 15h02

Si vous avez un pull down externe sur le bouton le test d'appui c'est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (digitalRead(pinBouton) == HIGH)

êtes vous sûr que vos relais sont actifs à HIGH ? souvent c'est LOW.

**jpbbricole** · 28/11/2021, 15h16

Bonjour Skarabee1969

Dans ton code il est dit:

Envoyé par Skarabee1969

le bouton poussoir est connecté au pin 2 avec une résistance pull-down de 10KO

et tu testes.
if (digitalRead(pinBouton) == LOW) { // appui
Il y a contradiction!
Ca devrait plutôt être:
le bouton poussoir est connecté au pin 2 avec une résistance pull-UP de 10KO, c'est à dire connectée entre la pin 2 et le +5V.

Mais tu peux te simplifier la vie, dans una application si simple la résistance te le condensateur ne sont pas vraiment nécessaire, vu que le temps d'attarction des relais "couvre" largement les rebonds possibles. Mais pour ce faire il faut initialiser ton bouton ainsi:
pinMode(pinBouton, INPUT_PULLUP); //mode lecture pour le bouton
Ainsi tu utilises la PULL_UP interne de l'Arduino.

Pour simplifier l'usage des boutons, tournes-toi du côté des bibliothèques comme button, ça permet plus de trucs avec des boutons.
Je te fais un exemple do ton programme, avec.

Cordialement
jpbbricole

**Skarabee1969** · 28/11/2021, 15h38

Pour l'instant je fais mes essais sur simulateur.

Après plusieurs tests j'ai ce que je recherche en enlevant le condensateur et en utilisant 2 résistances reliées au bouton poussoir.
La borne 1 du bouton poussoir est reliée au +5v
La borne 2 a une résistance de 1K relier au GND et une autre résistance de 100 ohms relier a la pin 2

Avec ces modifications ça a l'air de fonctionner, par contre je ne sais pas si c'est "réglementaire".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
 
le bouton poussoir est connecté au pin 2 avec une résistance pull-down de 10KΩ
 
les LED sont connectées aux pins 4 et 6 avec des résistances de 220Ω
 
*/
 
//déclaration des variables
 
int pinBouton;
int pinRelai1, pinRelai2;
 
void setup() {   //initialisation des variables
 
pinBouton = 2;
pinRelai1 = 3;
pinRelai2 = 4;
 
//définition des modes
 
pinMode(pinBouton, INPUT); //mode lecture pour le bouton
pinMode(pinRelai1, OUTPUT); //mode écriture pour led1
pinMode(pinRelai2, OUTPUT); //mode écriture pour led2
 
}
 
void loop() {
  if (digitalRead(pinBouton) == HIGH) { // appui
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau bas)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau bas)
    delay(1000); // attente de 1s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(4000); // attente de 4s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
    while(digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
  }
}

**jpbbricole** · 28/11/2021, 15h47

Bonjour Bonjour Skarabee1969

Si tu ne mets rien, si ce n'est que ton bouton relié à GND d'un côté et à la pin 2 de l'autre, que tu initialises le bouton
pinMode(pinBouton, INPUT_PULLUP); //mode lecture pour le bouton

et que tu lis ton bouton
if (digitalRead(pinBouton) == LOW) { // appui

Ca te supprime résistances et condensateur.

Une version avec button.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <Button.h>
 
//déclaration des variables
const int pinBouton = 2;
const int pinRelai1 = 3;
const int pinRelai2 = 4;
 
Button bouton(pinBouton); // Connect your button between pin pinBouton and GND
 
void setup() 
{   
	bouton.begin();
 
	pinMode(pinRelai1, OUTPUT); //mode écriture pour led1
	pinMode(pinRelai2, OUTPUT); //mode écriture pour led2
	digitalWrite(pinRelai1, LOW);
	digitalWrite(pinRelai2, LOW);
}
 
void loop()
{
  if (bouton.pressed())     // appui
  { 
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau bas)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau bas)
    delay(1000); // attente de 1s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(4000); // attente de 4s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
  }
}

Cordialement
jpbbricole

**Skarabee1969** · 28/11/2021, 16h04

Génial ça simplifie le montage.

Merci beaucoup pour toute l'aide que tu m'as apportée.

**Jay M** · 28/11/2021, 16h41

vérifiez si vos relais sont actifs à LOW ou HIGH (le code et le commentaire ne correspondent pas)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau bas)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau bas)

**Skarabee1969** · 28/11/2021, 20h16

Tout est OK j'avais juste oublié de modifié les commentaires.

Encore mille mercis pour le coup de main.

**Skarabee1969** · 08/12/2021, 10h34

Rebonjour,

Je souhaite améliorer mon système en intégrant 4 cycles dont la différence est juste la tempo du relais 2 qui change.
A l'allumage de l'arduino, celui-ci se met en attente d'appui sur le BP.
Lorsque j’appuie sur le BP le cycle 1 s'enclenche et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
Un nouvel appui sur le BP lance le cycle 2 et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
Un nouvel appui sur le BP lance le cycle 3 et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
Un nouvel appui sur le BP lance le cycle 4 et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
Un nouvel appui sur le BP lance le cycle 1 et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
Un nouvel appui sur le BP lance le cycle 2 et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
Un nouvel appui sur le BP lance le cycle 3 et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.
etc.

J'ai vu qu'il fallait utiliser une fonction spécifique pour ça, il me semble boolean, mais je ne sais pas comment la mettre en application.
D'avance merci pour votre aide.

**Jay M** · 08/12/2021, 12h25

si vous avez 2 (ou plus) cycles et que le bouton permet d'interrompre un cycle en cours pour passer à un autre cycle, vous ne pouvez plus avoir un cycle décrit de manière séquentielle en utilisant delay() car vous n'écouterez pas le bouton pendant ce temps là.

il faut repenser tout le code (une machine à états par exemple) et utiliser millis() pour gérer le temps cf les cahiers pratiques et notamment Comment gérer le temps ?

**Skarabee1969** · 08/12/2021, 13h35

Non le BP ne doit pas interrompre le cycle.

**Jay M** · 08/12/2021, 14h55

Vous avez écrit

Lorsque j’appuie sur le BP le cycle 1 s'enclenche et ensuite l'arduino se met en attente d'un nouvel appui sur le BP.

Concrètement que doit il se passer quand vous appuyez la première fois puis ensuite à chaque appui (si vous appuyez pendant le cycle par exemple)

Si le cycle ne peut pas être interrompu alors il suffit de tester et attendre l’appui du bouton après le cycle en cours

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void loop() {
  while (digitalRead(pinBouton) == HIGH); // attendre appui
  cycle1();
 
  while (digitalRead(pinBouton) == HIGH); // attendre appui
  cycle2();
 
  while (digitalRead(pinBouton) == HIGH); // attendre appui
  cycle3();
}

**Skarabee1969** · 08/12/2021, 16h20

Je viens de faire la modification avec vos informations et cela correspond tout à fait à ce que je recherche.
Pour l'instant j'ai fait le test sur simulateur PC, ce soir j’essaie sur le montage réel.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
 
le bouton poussoir est connecté au pin 2 avec une résistance pull-down de 10KΩ
 
les LED sont connectées au pins 4 et 6 avec des résistances de 220Ω
 
*/
 
//déclaration des variables
 
int pinBouton;
int pinRelai1, pinRelai2;
 
void setup() {   //initialisation des variables
 
pinBouton = 2;
pinRelai1 = 3;
pinRelai2 = 4;
 
//définition des modes
 
pinMode(pinBouton, INPUT_PULLUP); //mode lecture pour le bouton
pinMode(pinRelai1, OUTPUT); //mode écriture pour led1
pinMode(pinRelai2, OUTPUT); //mode écriture pour led2
 
}
 
void loop() {
 
  while (digitalRead(pinBouton) == HIGH); // attendre appui
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau haut)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau haut)
    delay(200); // attente de 0.2s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(4000); // attente de 4s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
    while(digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
 
  while (digitalRead(pinBouton) == HIGH); // attendre appui
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau haut)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau haut)
    delay(200); // attente de 0.2s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(7000); // attente de 7s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
    while(digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
 
  while (digitalRead(pinBouton) == HIGH); // attendre appui
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau haut)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau haut)
    delay(200); // attente de 0.2s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(6000); // attente de 6s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
    while(digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
 
   while (digitalRead(pinBouton) == HIGH); // attendre appui
    digitalWrite(pinRelai1, HIGH); // activation relai #1 (en supposant qu'il est actif au niveau haut)
    digitalWrite(pinRelai2, HIGH); // activation relai #2 (en supposant qu'il est actif au niveau haut)
    delay(200); // attente de 0.2s
    digitalWrite(pinRelai1, LOW); // désactivation relai #1
    delay(8000); // attente de 8s
    digitalWrite(pinRelai2, LOW); // désactivation relai #2
    while(digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
    delay(15); // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
}

**Jay M** · 09/12/2021, 18h16

pour améliorer votre code, au lieu de faire cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
//déclaration des variables
 
int pinBouton;
int pinRelai1, pinRelai2;
 
void setup() {   //initialisation des variables
 
pinBouton = 2;
pinRelai1 = 3;
pinRelai2 = 4;
...

faites plutôt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
//déclaration des variables
 
const byte pinBouton = 2;
const byte pinRelai1 = 3;
const byte pinRelai2 = 4;
 
void setup() {   //initialisation des variables
 ...

et si vous regardez vos cycles, il n'y a qu'une seule durée qui change, donc autant en faire une fonction avec un paramètre.

ça donnerait cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const byte pinBouton = 2;
const byte pinRelai1 = 3;
const byte pinRelai2 = 4;
 
void cycle(unsigned long duree) {
  while (digitalRead(pinBouton) == HIGH); // attendre appui
  digitalWrite(pinRelai1, HIGH);          // activation relai #1 (en supposant qu'il est actif au niveau haut)
  digitalWrite(pinRelai2, HIGH);          // activation relai #2 (en supposant qu'il est actif au niveau haut)
  delay(200);                             // attente de 0.2s
  digitalWrite(pinRelai1, LOW);           // désactivation relai #1
  delay(duree);                           // attente durée variable
  digitalWrite(pinRelai2, LOW);           // désactivation relai #2
  while (digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
  delay(15);                              // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
}
 
void setup() {
  //définition des modes
  pinMode(pinBouton, INPUT_PULLUP); //mode lecture pour le bouton
  pinMode(pinRelai1, OUTPUT); //mode écriture pour led1
  pinMode(pinRelai2, OUTPUT); //mode écriture pour led2
}
 
void loop() {
  cycle(4000);
  cycle(7000);
  cycle(6000);
  cycle(8000);
}

c'est plus simple à lire non ?

et si on veut encore simplifier, on peut mettre un tableau qui sera parcouru dans la loop

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
const unsigned long cycles[] = {4000, 7000, 6000, 8000};
 
const byte pinBouton = 2;
const byte pinRelai1 = 3;
const byte pinRelai2 = 4;
 
void cycle(unsigned long duree) {
  while (digitalRead(pinBouton) == HIGH); // attendre appui
  digitalWrite(pinRelai1, HIGH);          // activation relai #1 (en supposant qu'il est actif au niveau haut)
  digitalWrite(pinRelai2, HIGH);          // activation relai #2 (en supposant qu'il est actif au niveau haut)
  delay(200);                             // attente de 0.2s
  digitalWrite(pinRelai1, LOW);           // désactivation relai #1
  delay(duree);                           // attente durée variable
  digitalWrite(pinRelai2, LOW);           // désactivation relai #2
  while (digitalRead(pinBouton) == HIGH); // attente active de relâchement du bouton
  delay(15);                              // juste pour éviter les rebonds si vous n'avez pas mis le condensateur
}
 
void setup() {
  pinMode(pinBouton, INPUT_PULLUP); //mode lecture pour le bouton
  pinMode(pinRelai1, OUTPUT); //mode écriture pour led1
  pinMode(pinRelai2, OUTPUT); //mode écriture pour led2
}
 
void loop() {
  for (auto && d : cycles) cycle(d);
}

comme cela pour définir l'automate on n'a qu'à modifier la première ligne du code uniquement

**Skarabee1969** · 09/12/2021, 20h51

Alors là effectivement c'est beaucoup plus simple a lire, jamais j'aurais pensé a utiliser une fonction et encore moins un tableau, la c'est de la programmation de haut niveau.

, merci beaucoup pour votre aide

, je vais pouvoir avancer dans la réalisation de mon projet.

Activer deux relais pour un cycle avec un bouton poussoir

Arduino

Vue hybride

Discussions similaires

Partager

Partager