Résolution programme ARDUINO

**brachol** · 11/03/2020, 12h45

Bonjour Jay M,
J'ai commis une erreur sur mon dernier message, en fait le dernier code marchait juste pour la descente, une fois en bas, même le bouton ne remonte pas, pour le refaire remonter j'ai du téléverser le code du début, cordialement

**Jay M** · 12/03/2020, 16h42

vous pouvez me montrer ce que dit la console série... sinon je ne peux pas essayer de comprendre...

**brachol** · 12/03/2020, 17h18

Le code était comme ça :
18:55:24.510 -> ALLUMAGE BOUTON BAS
18:55:34.534 -> off sony
18:55:34.603 -> off sony
18:55:34.639 -> off sony

Et plus rien d'autre malgré l'appui sur les boutons ou télécommande.
Cordialement

**Jay M** · 13/03/2020, 14h02

Envoyé par brachol

Le code était comme ça :
18:55:24.510 -> ALLUMAGE BOUTON BAS
18:55:34.534 -> off sony
18:55:34.603 -> off sony
18:55:34.639 -> off sony

Et plus rien d'autre malgré l'appui sur les boutons ou télécommande.
Cordialement

si vous avez vu "off sony" c'est que vous n'aviez pas mis le dernier Code (qui dit "power sony").

==> le voici à nouveau:

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/* pins
 
  GND breadboard <--> GND Arduino (en cas d'usage d'une breadboard)
 
  D0, D1    connexion Serial
  D2
  D3        LED infrarouge (exemple TSAL 6200, (câblage pin 3 <-> R 200 Ohms  <-> LED Anode || Led Cathode <-> GND)
  D4        bouton poussoir haut (câblage pin 4 <-> bouton <-> GND)
  D5        bouton poussoir bas  (câblage pin 5 <-> bouton <-> GND)
  D6
  D7
  D8
  D9        IN1 = relais de montée
  D10       IN2 = relais de descente
  D11
  D12     Récepteur IR
  D13
 
  A0
  A1
  A2
  A3
  A4
  A5
 
*/
 
/* **************** la partie IR **************** */
 
#include <IRremote.h>     // https://github.com/z3t0/Arduino-IRremote
const byte RECV_PIN = 12; // on reçoit les commandes IR  PIN 12
IRrecv irrecv(RECV_PIN);  // notre objet récepteur
decode_results results;   // le résultat décodé
 
// LED IR connectée sur la pin PWM 3
/* obtention du code on/off de la télécommande sony à obtenir avec IRrecvDumpV2
  hypothèse ---> Decoded SONY: 542A (15 bits)
*/
const unsigned long codeProjecteurOFF = 0x542A; // (votre 21546)
const int longeurCodeSony = 15;
const unsigned long codeStarcom8810OFF = 0x2FD18E7; // (code OFF starcom8810)
 
IRsend irsend;
 
/* **************** les relais et boutons **************** */
 
const byte pinRelaisMonter = 9;       // IN1 = relais de montée
const byte pinRelaisDescendre = 10;   // IN2 = relais de descente
const byte ACTIF    = LOW;
const byte PASSIF =  HIGH;
const unsigned long dureeCourseAscenseur = 10000UL;
const unsigned long dureeRefroidissement = 120000UL;
 
const byte pinBoutonHaut = 4;  // bouton poussoir haut
const byte pinBoutonBas = 6;   // bouton poussoir bas
 
/* **************** gestion de l'état **************** */
 
enum : uint8_t {PROJECTEUR_OFF, PROJECTEUR_ON} etat;
 
/* **************** fonctions **************** */
void relais(const byte etatMonter, const byte etatDescendre)
{
  digitalWrite(pinRelaisMonter, etatMonter);
  digitalWrite(pinRelaisDescendre, etatDescendre);
}
 
void appuiPower() // le protocole Sony dit qu'il faut envoyer la commande 3 fois
{
  for (byte i = 0; i < 3; i++) {
    irsend.sendSony(codeProjecteurOFF, longeurCodeSony);
    Serial.println(F("power sony"));
    delay(40);
  }
}
 
void allumage()
{
  relais(PASSIF, ACTIF);        // active le relais descend et desactive le relais monte
  delay(dureeCourseAscenseur);  // attente de la descente
  relais(PASSIF, PASSIF);       // désactive les 2 relais
  appuiPower();
  etat = PROJECTEUR_ON;
}
 
void extinction(bool manuelle)
{
  if (manuelle) appuiPower();   // désactive le retroprojecteur
  delay(2000UL);                // on attend deux secondes
  Serial.println(F("CONFIRMATION OFF"));
  appuiPower();                 // confirmation désactivation du retroprojecteur
  delay(dureeRefroidissement);  // deux minutes de refroidissement
  relais(ACTIF, PASSIF);        // active le relais monte et desactive le relais descend
  delay(dureeCourseAscenseur);  // attente de la fermeture
  relais(PASSIF, PASSIF);       // désactive les 2 relais
  etat = PROJECTEUR_OFF;
}
 
 
uint32_t codeTelecommande()
{
  uint32_t code = 0;
  if (irrecv.decode(&results)) {
    code = results.value;
    Serial.print(F("code = 0x"));
    Serial.println(results.value, HEX);
    irrecv.resume();  // prêt pour traiter la prochaine commande
  }
  return code;
}
 
 
void setup()
{
  Serial.begin(115200);
 
  pinMode(pinRelaisMonter, OUTPUT);       //relais montée
  pinMode(pinRelaisDescendre, OUTPUT);    // relais descente
  relais(PASSIF, PASSIF);                 //extinction des relais
 
  etat = PROJECTEUR_OFF;                  // hypothèse, on a aucun moyen de savoir...
 
  pinMode (pinBoutonHaut, INPUT_PULLUP);  // activation du PULLUP interne
  pinMode (pinBoutonBas, INPUT_PULLUP);   // activation du PULLUP interne
 
  irrecv.enableIRIn(); // on commmence à écouter
}
 
void loop()
{
  switch (etat) {
    case PROJECTEUR_OFF:
      if (digitalRead(pinBoutonBas) == ACTIF) {
        Serial.println(F("ALLUMAGE BOUTON BAS"));
        allumage(); // appel bloquant ~10 secondes
      }
      break;
 
    case PROJECTEUR_ON:
      if (codeTelecommande() == codeStarcom8810OFF) {
        Serial.println(F("EXTINCTION STARCOM"));
        extinction(true); // extinction par télécommande différente de celle du Sony, donc on force l'extinction, appel bloquant plus de 2 minutes !
      } else if (digitalRead(pinBoutonHaut) == ACTIF) {
        Serial.println(F("EXTINCTION BOUTON HAUT"));
        extinction(true); // extinction manuelle, appel bloquant plus de 2 minutes !
      }
      break;
  }
}

**Jay M** · 13/03/2020, 22h45

Vous pouvez tester avec un petit code de démo IR qui lit simplement la commande IR et affiche le code pour voir si votre système est fonctionnel ?

Le récepteur est il bien branché sur la pin 12 ?

**brachol** · 13/03/2020, 23h12

Le système marche, rappelez-vous :

18:56:34.979 -> code = 0x2FD18E7
18:56:34.979 -> EXTINCTION STARCOM
18:56:35.012 -> off sony
18:56:35.049 -> off sony
18:56:35.120 -> off sony
18:56:37.202 -> off sony
18:56:37.270 -> off sony
18:56:37.338 -> off sony

ça c'était le code d'avant avec un reset de l'arduino avec le rétro en bas et en route, sans appuyé sur les boutons mécanique, juste la télécommande

ma télécommande marche aussi, je regarde toujours avec mon appareil photo et la diode émet bien, la démo ir arduino aussi.

**brachol** · 14/03/2020, 18h31

test IR :

18:28:47.766 -> Enabling IRin
18:28:47.766 -> Enabled IRin
18:29:08.953 -> 2FD18E7
18:29:09.063 -> FFFFFFFF
18:29:13.976 -> 2FD18E7
18:29:14.150 -> FFFFFFFF

**Jay M** · 15/03/2020, 11h49

Envoyé par brachol

test IR :

18:28:47.766 -> Enabling IRin
18:28:47.766 -> Enabled IRin
18:29:08.953 -> 2FD18E7
18:29:09.063 -> FFFFFFFF
18:29:13.976 -> 2FD18E7
18:29:14.150 -> FFFFFFFF

Ah c'est une télécommande qui n'envoie qu'une seule fois son code 0x2FD18E7 et ensuite elle envoie des 0xFFFFFFFF pour dire répétition du dernier code.
Donc si on rate le premier on devrait voir passer des 0xFFFFFFFF

Je vous propose de renverser la machine à état et tester les évenements dans l'autre sens on verra mieux ce qu'il se passe. Pouvez vous essayer avec ce code:

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
/* pins
 
  GND breadboard <--> GND Arduino (en cas d'usage d'une breadboard)
 
  D0, D1    connexion Serial
  D2
  D3        LED infrarouge (exemple TSAL 6200, (câblage pin 3 <-> R 200 Ohms  <-> LED Anode || Led Cathode <-> GND)
  D4        bouton poussoir haut (câblage pin 4 <-> bouton <-> GND)
  D5        bouton poussoir bas  (câblage pin 5 <-> bouton <-> GND)
  D6
  D7
  D8
  D9        IN1 = relais de montée
  D10       IN2 = relais de descente
  D11
  D12       Récepteur IR
  D13
 
  A0
  A1
  A2
  A3
  A4
  A5
 
*/
 
/* **************** la partie IR **************** */
 
#include <IRremote.h>     // https://github.com/z3t0/Arduino-IRremote
const byte RECV_PIN = 12; // on reçoit les commandes IR  PIN 12
IRrecv irrecv(RECV_PIN);  // notre objet récepteur
decode_results results;   // le résultat décodé
 
// LED IR connectée sur la pin PWM 3
/* obtention du code on/off de la télécommande sony à obtenir avec IRrecvDumpV2
  hypothèse ---> Decoded SONY: 542A (15 bits)
*/
const unsigned long codeProjecteurOFF = 0x542A; // (votre 21546)
const int longeurCodeSony = 15;
const unsigned long codeStarcom8810OFF = 0x2FD18E7; // (code OFF starcom8810)
 
IRsend irsend;
 
/* **************** les relais et boutons **************** */
 
const byte pinRelaisMonter = 9;       // IN1 = relais de montée
const byte pinRelaisDescendre = 10;   // IN2 = relais de descente
const byte ACTIF    = LOW;
const byte PASSIF =  HIGH;
const unsigned long dureeCourseAscenseur = 10000UL;
const unsigned long dureeRefroidissement = 120000UL;
 
const byte pinBoutonHaut = 4;  // bouton poussoir haut
const byte pinBoutonBas = 6;   // bouton poussoir bas
 
/* **************** gestion de l'état **************** */
 
enum : uint8_t {PROJECTEUR_OFF, PROJECTEUR_ON} etat;
 
/* **************** fonctions **************** */
void relais(const byte etatMonter, const byte etatDescendre)
{
  digitalWrite(pinRelaisMonter, etatMonter);
  digitalWrite(pinRelaisDescendre, etatDescendre);
}
 
void appuiPower() // le protocole Sony dit qu'il faut envoyer la commande 3 fois
{
  for (byte i = 0; i < 3; i++) {
    irsend.sendSony(codeProjecteurOFF, longeurCodeSony);
    Serial.println(F("power sony"));
    delay(40);
  }
}
 
void allumage()
{
  relais(PASSIF, ACTIF);        // active le relais descend et desactive le relais monte
  delay(dureeCourseAscenseur);  // attente de la descente
  relais(PASSIF, PASSIF);       // désactive les 2 relais
  appuiPower();
  etat = PROJECTEUR_ON;
}
 
void extinction(bool manuelle)
{
  if (manuelle) appuiPower();   // désactive le retroprojecteur
  delay(2000UL);                // on attend deux secondes
  Serial.println(F("CONFIRMATION OFF"));
  appuiPower();                 // confirmation désactivation du retroprojecteur
  delay(dureeRefroidissement);  // deux minutes de refroidissement
  relais(ACTIF, PASSIF);        // active le relais monte et desactive le relais descend
  delay(dureeCourseAscenseur);  // attente de la fermeture
  relais(PASSIF, PASSIF);       // désactive les 2 relais
  etat = PROJECTEUR_OFF;
}
 
 
uint32_t codeTelecommande()
{
  uint32_t code = 0;
  if (irrecv.decode(&results)) {
    code = results.value;
    irrecv.resume();  // prêt pour traiter la prochaine commande
  }
  return code;
}
 
 
void setup()
{
  Serial.begin(115200);
 
  pinMode(pinRelaisMonter, OUTPUT);       //relais montée
  pinMode(pinRelaisDescendre, OUTPUT);    // relais descente
  relais(PASSIF, PASSIF);                 //extinction des relais
 
  etat = PROJECTEUR_OFF;                  // hypothèse, on a aucun moyen de savoir...
 
  pinMode (pinBoutonHaut, INPUT_PULLUP);  // activation du PULLUP interne
  pinMode (pinBoutonBas, INPUT_PULLUP);   // activation du PULLUP interne
 
  irrecv.enableIRIn();                    // on commmence à écouter
}
 
void loop()
{
  uint32_t code = codeTelecommande();
 
  if (code == codeStarcom8810OFF) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("Starcom etat off, on ignore."));
        break;
      case PROJECTEUR_ON:
        Serial.println(F("EXTINCTION STARCOM"));
        extinction(true); // extinction par télécommande différente de celle du Sony, donc on force l'extinction, appel bloquant plus de 2 minutes !
        break;
    }
  } else if (code != 0) { // on a reçu un code qui n'est pas codeStarcom8810OFF
    Serial.print(F("RECPTION IR NON CONNUE: 0x"));
    Serial.println(code, HEX);
  }
 
  // séparément on traite aussi les boutons
 
  // test appui BAS
  if (digitalRead(pinBoutonBas) == ACTIF) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("ALLUMAGE BOUTON BAS"));
        allumage(); // appel bloquant ~10 secondes
        break;
      case PROJECTEUR_ON:
        Serial.println(F("Appui bas etat ON, on ignore."));
        delay(15); // anti-rebond du pauvre
        break;
    }
  }
 
  // test appui HAUT
  if (digitalRead(pinBoutonHaut) == ACTIF) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("Appui haut etat OFF, on ignore."));
        delay(15); // anti-rebond du pauvre
        break;
      case PROJECTEUR_ON:
        Serial.println(F("EXTINCTION BOUTON HAUT"));
        extinction(true); // extinction manuelle, appel bloquant plus de 2 minutes !
        break;
    }
  }
}

**brachol** · 15/03/2020, 12h12

Bonjour Jay M,
Si j'appuie sur la telecommande, juste après avoir televersé :

12:08:34.137 -> Starcom etat off, on ignore.
12:08:34.210 -> RECPTION IR NON CONNUE: 0xFFFFFFFF

Si je touche a un bouton on ne detecte plus la telecommande après :

12:11:26.241 -> Starcom etat off, on ignore.
12:11:31.616 -> ALLUMAGE BOUTON BAS
12:11:41.609 -> power sony
12:11:41.681 -> power sony
12:11:41.751 -> power sony
12:12:13.613 -> EXTINCTION BOUTON HAUT
12:12:13.647 -> power sony
12:12:13.719 -> power sony
12:12:13.753 -> power sony
12:12:15.812 -> CONFIRMATION OFF
12:12:15.848 -> power sony
12:12:15.884 -> power sony
12:12:15.953 -> power sony

**Jay M** · 15/03/2020, 17h29

pouvez vous testez ce code:

il ne pilotera rien du tout mais effectue les affichages. Si ce code fonctionne c'est qu'il y a un souci ailleurs dans la logique ou des perturbations

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/* **************** la partie IR **************** */
 
#include <IRremote.h>     // https://github.com/z3t0/Arduino-IRremote
const byte RECV_PIN = 12; // on reçoit les commandes IR  PIN 12
IRrecv irrecv(RECV_PIN);  // notre objet récepteur
decode_results results;   // le résultat décodé
 
const unsigned long codeStarcom8810OFF = 0x2FD18E7; // (code OFF starcom8810)
IRsend irsend;
 
const byte pinBoutonHaut = 4;  // bouton poussoir haut
const byte pinBoutonBas = 6;   // bouton poussoir bas
 
/* **************** gestion de l'état **************** */
 
enum : uint8_t {PROJECTEUR_OFF, PROJECTEUR_ON} etat;
 
/* **************** fonctions **************** */
 
void allumage()
{
  etat = PROJECTEUR_ON;
  Serial.println(F("LE PROECTEUR EST EN BAS"));
}
 
void extinction()
{
  etat = PROJECTEUR_OFF;
  Serial.println(F("LE PROECTEUR EST EN HAUT"));
}
 
uint32_t codeTelecommande()
{
  uint32_t code = 0;
  if (irrecv.decode(&results)) {
    code = results.value;
    irrecv.resume();  // prêt pour traiter la prochaine commande
  }
  return code;
}
 
void setup()
{
  Serial.begin(115200);
  pinMode (pinBoutonHaut, INPUT_PULLUP);  // activation du PULLUP interne
  pinMode (pinBoutonBas, INPUT_PULLUP);   // activation du PULLUP interne
  etat = PROJECTEUR_OFF;                  // hypothèse, on a aucun moyen de savoir...
  Serial.println(F("LE PROECTEUR EST EN HAUT"));
  irrecv.enableIRIn();                    // on commmence à écouter
}
 
void loop()
{
  uint32_t code = codeTelecommande();
 
  if (code == codeStarcom8810OFF) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("Starcom IR en etat off, on ignore."));
        break;
      case PROJECTEUR_ON:
        Serial.println(F("EXTINCTION STARCOM IR"));
        extinction();
        break;
    }
  } else if (code != 0) { // on a reçu un code qui n'est pas codeStarcom8810OFF
    Serial.print(F("RECPTION IR NON CONNUE: 0x"));
    Serial.println(code, HEX);
  }
 
  // séparément on traite aussi les boutons
 
  // test appui BAS
  if (digitalRead(pinBoutonBas) == LOW) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("ALLUMAGE BOUTON BAS"));
        allumage();
        break;
      case PROJECTEUR_ON:
        Serial.println(F("Appui BOUTON BAS en etat ON, on ignore."));
        break;
    }
  }
 
  // test appui HAUT
  if (digitalRead(pinBoutonHaut) == LOW) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("Appui BOUTON HAUT en etat OFF, on ignore."));
        break;
      case PROJECTEUR_ON:
        Serial.println(F("EXTINCTION BOUTON HAUT"));
        extinction(); // extinction manuelle, appel bloquant plus de 2 minutes !
        break;
    }
  }
  delay(15); // anti-rebond du pauvre
}

**Jay M** · 15/03/2020, 18h12

OK donc ça à l'air de marcher, on peut utiliser la télécommande ou les boutons en permanence...

17:56:16.718 -> LE PROECTEUR EST EN HAUT état initial
17:56:23.475 -> ALLUMAGE BOUTON BAS bouton pour descendre
17:56:23.475 -> LE PROECTEUR EST EN BAS on est en bas
17:56:23.475 -> Appui BOUTON BAS en etat ON, on ignore. donc si on appuie sur le bouton on ignore
...
17:56:41.392 -> EXTINCTION STARCOM IR La télécommande demande extinction
17:56:41.392 -> LE PROECTEUR EST EN HAUT le projo remonte et s'éteint
17:56:41.428 -> RECPTION IR NON CONNUE: 0xFFFFFFFF rebonds de la télécommande sont ignorés
17:56:41.537 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:56:41.645 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:56:50.615 -> Starcom IR en etat off, on ignore. appui à nouveau sur Starcom mais comme on est off on ignore
...
17:57:00.013 -> Appui BOUTON HAUT en etat OFF, on ignore. appui sur bouton HAUT mais comme on est off on ignore
17:57:00.013 -> Appui BOUTON HAUT en etat OFF, on ignore. répétitions on continue à ignorer
...
17:57:20.376 -> Starcom IR en etat off, on ignore. appui à nouveau sur Starcom mais comme on est off on ignore

==>Le problème ne vient donc sans doute pas de l'architecture du code, mais d'un truc louche ailleurs... est-ce que la carte et son circuit, les GND etc sont bien isolés des perturbations des moteurs et courants forts ?

**brachol** · 15/03/2020, 18h19

J'utilise du cable de téléphone, mais pourquoi quand je fais un reset à l'allumage et à l'extinction ça marche ? si il y a des perturbations, le reset ne les enlèves pas.

**Jay M** · 15/03/2020, 18h39

Envoyé par brachol

J'utilise du cable de téléphone, mais pourquoi quand je fais un reset à l'allumage et à l'extinction ça marche ? si il y a des perturbations, le reset ne les enlèves pas.

le reset est fait après le mouvement des moteurs qui sont les gros générateurs de perturbations electro magnétiques - mais je n'ai pas de réponse précise.

essayez le code de test mais en rajoutant un délai de une minute pendant les actions pour voir si c'est le temps d'attente qui met le souk...

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/* **************** la partie IR **************** */
 
#include <IRremote.h>     // https://github.com/z3t0/Arduino-IRremote
const byte RECV_PIN = 12; // on reçoit les commandes IR  PIN 12
IRrecv irrecv(RECV_PIN);  // notre objet récepteur
decode_results results;   // le résultat décodé
 
const unsigned long codeStarcom8810OFF = 0x2FD18E7; // (code OFF starcom8810)
IRsend irsend;
 
const byte pinBoutonHaut = 4;  // bouton poussoir haut
const byte pinBoutonBas = 6;   // bouton poussoir bas
 
/* **************** gestion de l'état **************** */
 
enum : uint8_t {PROJECTEUR_OFF, PROJECTEUR_ON} etat;
 
/* **************** fonctions **************** */
 
void allumage()
{
  etat = PROJECTEUR_ON;
  Serial.println(F("LE PROJECTEUR DESCEND"));
  delay(60000UL);
  Serial.println(F("LE PROJECTEUR EST EN BAS"));}
 
void extinction()
{
  etat = PROJECTEUR_OFF;
  Serial.println(F("LE PROJECTEUR REMONTE"));
  delay(60000UL);
  Serial.println(F("LE PROJECTEUR EST EN HAUT"));}
}
 
uint32_t codeTelecommande()
{
  uint32_t code = 0;
  if (irrecv.decode(&results)) {
    code = results.value;
    irrecv.resume();  // prêt pour traiter la prochaine commande
  }
  return code;
}
 
void setup()
{
  Serial.begin(115200);
  pinMode (pinBoutonHaut, INPUT_PULLUP);  // activation du PULLUP interne
  pinMode (pinBoutonBas, INPUT_PULLUP);   // activation du PULLUP interne
  etat = PROJECTEUR_OFF;                  // hypothèse, on a aucun moyen de savoir...
  Serial.println(F("LE PROECTEUR EST EN HAUT"));
  irrecv.enableIRIn();                    // on commmence à écouter
}
 
void loop()
{
  uint32_t code = codeTelecommande();
 
  if (code == codeStarcom8810OFF) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("Starcom IR en etat off, on ignore."));
        break;
      case PROJECTEUR_ON:
        Serial.println(F("EXTINCTION STARCOM IR"));
        extinction();
        break;
    }
  } else if (code != 0) { // on a reçu un code qui n'est pas codeStarcom8810OFF
    Serial.print(F("RECPTION IR NON CONNUE: 0x"));
    Serial.println(code, HEX);
  }
 
  // séparément on traite aussi les boutons
 
  // test appui BAS
  if (digitalRead(pinBoutonBas) == LOW) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("ALLUMAGE BOUTON BAS"));
        allumage();
        break;
      case PROJECTEUR_ON:
        Serial.println(F("Appui BOUTON BAS en etat ON, on ignore."));
        break;
    }
  }
 
  // test appui HAUT
  if (digitalRead(pinBoutonHaut) == LOW) {
    switch (etat) {
      case PROJECTEUR_OFF:
        Serial.println(F("Appui BOUTON HAUT en etat OFF, on ignore."));
        break;
      case PROJECTEUR_ON:
        Serial.println(F("EXTINCTION BOUTON HAUT"));
        extinction(); // extinction manuelle, appel bloquant plus de 2 minutes !
        break;
    }
  }
  delay(15); // anti-rebond du pauvre
}

**brachol** · 16/03/2020, 18h02

Bonjour Jay M,

resultat code dans moniteur :

17:50:47.469 -> ALLUMAGE BOUTON BAS
17:50:47.469 -> LE PROJECTEUR DESCEND
17:51:47.453 -> LE PROJECTEUR EST EN BAS
17:52:04.770 -> EXTINCTION BOUTON HAUT
17:52:04.770 -> LE PROJECTEUR REMONTE
17:53:04.712 -> LE PROJECTEUR EST EN HAUT
17:53:10.290 -> ALLUMAGE BOUTON BAS
17:53:10.290 -> LE PROJECTEUR DESCEND
17:54:10.250 -> LE PROJECTEUR EST EN BAS
17:54:14.966 -> EXTINCTION STARCOM IR
17:54:14.966 -> LE PROJECTEUR REMONTE
17:55:14.950 -> LE PROJECTEUR EST EN HAUT
17:55:14.950 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:55:28.794 -> ALLUMAGE BOUTON BAS
17:55:28.794 -> LE PROJECTEUR DESCEND
17:56:28.786 -> LE PROJECTEUR EST EN BAS
17:56:33.435 -> EXTINCTION BOUTON HAUT
17:56:33.435 -> LE PROJECTEUR REMONTE
17:57:33.388 -> LE PROJECTEUR EST EN HAUT
17:57:52.678 -> ALLUMAGE BOUTON BAS
17:57:52.678 -> LE PROJECTEUR DESCEND
17:58:52.645 -> LE PROJECTEUR EST EN BAS
17:58:55.755 -> EXTINCTION STARCOM IR
17:58:55.755 -> LE PROJECTEUR REMONTE
17:59:55.705 -> LE PROJECTEUR EST EN HAUT
17:59:55.705 -> RECPTION IR NON CONNUE: 0xFFFFFFFF

tout passe bien

**Jay M** · 16/03/2020, 18h16

Ok comme c’est globalement la même structure de code que la vraie version c’est qu’il y a un soucis dans le code de pilotage moteur ou le câblage...

Le code des relais étant extrêmement simple mais essayez un truc, remplacez la fonction des relais par

Code :

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

1
2
3
4
5
6
7
8
void relais(const byte etatMonter, const byte etatDescendre)
{
  digitalWrite(pinRelaisMonter, PASSIF);
  digitalWrite(pinRelaisDescendre, PASSIF);
  delay(1000);
  digitalWrite(pinRelaisMonter, etatMonter);
  digitalWrite(pinRelaisDescendre, etatDescendre);
}

L’objectif étant d’éliminer le risque d’un état bizarre parce que les deux commandes moteurs pourraient être activées pendant quelques micro secondes ensemble si d’aventure le moteur était encore en mouvement...

Ensuite vos relais sont ils adaptés à la tension de pilotage et ont ils une diode de protection etc ?

**brachol** · 16/03/2020, 19h10

J'utilise un module 2 relais speciale Arduino.

**Jay M** · 16/03/2020, 19h15

Envoyé par brachol

J'utilise un module 2 relais speciale Arduino.

C’est pas une spécification ça...

certes vous pouvez le piloter depuis les pins Arduino mais quel courant continu, tension, puissance est il capable de gérer ? Et est-ce compatible avec votre moteur / alimentation ?

**brachol** · 16/03/2020, 19h51

Nom : relais (2).jpg
Affichages : 111
Taille : 53,1 Ko

**Jay M** · 16/03/2020, 22h27

oui ça je me doutais - la question c'est ce que vous commandez: le moteur, quelles sont ses spécifications et quelle alimentation ?

**brachol** · 17/03/2020, 10h35

Bonjour Jay M,
Caracteristique du moteur :
- Force de traction : 10 Nm / 25 kg
- Vitesse : 17 U/min
- Diamètre du tuyau : 35 mm
- Tension: 230 volts
- Fréquence: 50 Hz
- Consommation : 0,53 A
- Puissance du moteur : 121 Watt

J'ai mesuré la montée en charge : 0.47 A

Après réfléctions, je vais laisser tomber l'arret à la télécommande car au final c'était pour le FUN. Le principal c'est que les boutons marche ainsi que l'envoi IR. La télécommande, c'était juste la flemme de se lever pou éteindre le rétro alors que je n'ai qu'a appuyer sur le bouton mural lol.

Résolution programme ARDUINO

Arduino

Vue hybride

Discussions similaires

Partager

Partager