Discussion :

[Jay M]

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]

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]

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]

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]

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

[brachol]

j'ai l'impression que dès que l'on touche les boutons, la reception IR ne marche plus.

[brachol]

Jay M,
Je viens de reprendre un de vos code avec le rajout de reset en void allumage et void extinction et tout marche, Mister Reset le retour :

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
/* 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 <-> R200Ω <-> 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
  D13
 
  A0
  A1
  A2
  A3
  A4
  A5
 
*/
 
/* **************** la partie IR **************** */
 
#include <IRremote.h>     // <a href="https://github.com/z3t0/Arduino-IRremote" target="_blank">https://github.com/z3t0/Arduino-IRremote</a>
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()
{
  //appuiPower();
  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();
  asm volatile ("  jmp 0");      // RESET
}
 
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
  asm volatile ("  jmp 0");      // RESET
}
 
 
uint32_t codeTelecommande()
{
  uint32_t code = 0;
  if (irrecv.decode(&results)) {
    code = results.value;
    Serial.print("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
      }
      etat = PROJECTEUR_ON;
      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 !
      }
      etat = PROJECTEUR_OFF;
      break;
  }
}

Et la console :

15:31:18.312 -> ALLUMAGE BOUTON BAS
15:31:28.325 -> power sony
15:31:28.397 -> power sony
15:31:28.469 -> power sony
15:32:00.534 -> code = 0x2FD18E7
15:32:00.534 -> EXTINCTION STARCOM
15:32:00.534 -> power sony
15:32:00.606 -> power sony
15:32:00.678 -> power sony
15:32:02.712 -> CONFIRMATION OFF
15:32:02.746 -> power sony
15:32:02.819 -> power sony
15:32:02.855 -> power sony
15:34:21.477 -> ALLUMAGE BOUTON BAS
15:34:31.501 -> power sony
15:34:31.573 -> power sony
15:34:31.646 -> power sony
15:35:17.072 -> EXTINCTION BOUTON HAUT
15:35:17.072 -> power sony
15:35:17.144 -> power sony
15:35:17.218 -> power sony
15:35:19.252 -> CONFIRMATION OFF
15:35:19.286 -> power sony
15:35:19.320 -> power sony
15:35:19.391 -> power sony
15:37:37.598 -> ALLUMAGE BOUTON BAS
15:37:47.616 -> power sony
15:37:47.687 -> power sony
15:37:47.722 -> power sony
15:38:17.721 -> code = 0x2FD18E7
15:38:17.721 -> EXTINCTION STARCOM
15:38:17.758 -> power sony
15:38:17.794 -> power sony
15:38:17.864 -> power sony
15:38:19.917 -> CONFIRMATION OFF
15:38:19.964 -> power sony
15:38:20.011 -> power sony
15:38:20.058 -> power sony

[Jay M]

j'ai l'impression que dès que l'on touche les boutons, la reception IR ne marche plus.

ôtez moi d'un doute, vos boutons ce sont bien des boutons momentanés ? on appuie dessus et ils remontent tout seul. ce ne sont pas des interrupteurs à position permanente ?
vous n'avez pas de court circuit ou quoi que ce soit de louche ?

pouvez vous partager une photo / description de comment ils sont câblés ?

le reset n'est pas satisfaisant, il n'y a aucune raison qu'il y ait besoin de faire reset et en plus ça fait perdre la mémoire à la machine à états donc on ne se souviendra plus dans quel état on est

[brachol]

Poussoir 500W maximum Mosaic pour 1 ou plusieurs volets roulants - blanc

Ce n'est pas un interrupteur, quand on lache le bouton pas de contact

[Jay M]

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
}

[brachol]

tout est raccordé sur arduino par connecteurs et alim 5V indépendante qui alimente l'arduino et les relais, seul les IRS sont alimentées par arduino.


les grounds sont centralisé sont centralisé


Alim relais et in1 et in2 sur connecteur.


220 V sur relais


boutons poussoir


boutons secours en double va et vient sur relais (si arduino claque, pour descendre le projo)


connectique étanche pour démontage


boite style tupperware pour protection arduino

Voila l'installation, cordialement.

[brachol]

17:56:16.718 -> LE PROECTEUR EST EN HAUT
17:56:23.475 -> ALLUMAGE BOUTON BAS
17:56:23.475 -> LE PROECTEUR EST EN BAS
17:56:23.475 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.511 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.511 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.545 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.545 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.545 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.581 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.581 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.618 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.618 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.654 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.654 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.654 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.689 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:23.689 -> Appui BOUTON BAS en etat ON, on ignore.
17:56:41.392 -> EXTINCTION STARCOM IR
17:56:41.392 -> LE PROECTEUR EST EN HAUT
17:56:41.428 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
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.
17:56:50.649 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:56:50.753 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:56:50.860 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:57:00.013 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.013 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.013 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.049 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.049 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.085 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.085 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.121 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.121 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.157 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.157 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.157 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.193 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.193 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.229 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.229 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:00.265 -> Appui BOUTON HAUT en etat OFF, on ignore.
17:57:20.376 -> Starcom IR en etat off, on ignore.
17:57:20.446 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:57:20.552 -> RECPTION IR NON CONNUE: 0xFFFFFFFF
17:57:20.659 -> RECPTION IR NON CONNUE: 0xFFFFFFFF

[Jay M]

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]

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]

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]

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]

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]

J'utilise un module 2 relais speciale Arduino.

[Jay M]

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]