Discussion :

[jojodu71]

Bonjour à tous,
Je suis nouveau sur ce Forum mais en même temps ancien avec un autre Pseudo auquel je n'ai plus accès. je me suis lancé dans la réalisation d'un jeu de tiercé du style que l'on peux trouver sur les fêtes foraine pour l'école de ma fille.
Le principe est de lancé une balle à travers des trou pour faire avancer des escargots et gagner la course. la détection de la balle se faisait avec un capteur IR de type FC51, mais sont fonctionnement était aléatoire en fonction de la luminosité. on m'a donc conseillé d'utilisé un Laser KY-008 associé à un capteur LDR. j'ai acheté le matériel et fait les modification. le capteur se coupe bien lorsque le faisceau est coupé (seul petit bémol, le contact est inversé par rapport à avant, la sortie est toujours à 1 et passe à 0 lors de la détection). le soucis que j'ai , est d'intégrer ces nouveaux capteurs dans mon code Arduino. Par contre, si je me débrouille en bricolage, je suis un peu novice en programmation Arduino. Si quelqu'un pouvait m'aider à résoudre mon problème , ce serait sympa. merci d'avance
cordialement

[umfred]

c'est quoi le souci à part inverser la détection sur un 0 au lieu de la faire sur un 1 ?

[jojodu71]

Merci beaucoup pour votre réponse. si j'ai bien compris ce que l'on m'a expliqué, les capteurs LDR peuvent s'initialiser à chaque cycle en fonction de la luminosité et ainsi éviter les aléas que j'avais avec les capteurs infrarouge qui eux fonctionnaient parfaitement lorsque je faisais la mise au point dans mon sous sol , mais qui ne marchait plus une fois dehors.
c'est toute cette phase d'initialisation que je ne comprend pas bien malgré les explications du code fournie par cette personne, je n'arrive pas à savoir comment l’intégrer au miens.Surtout qu'il y a 4 pistes de jeux comprenant chacun trois capteurs soit 12 au total. Si vous avez des idées ? merci pour tout

[Jay M]

Avez vous un lien sur votre capteur LDR ?

Si la détection fait un front de HIGH à LOW vous pouvez simplement utiliser une classe bouton pour gérer votre système.

Le code doit être relativement simple, si vous décrivez un peu plus votre projet, on doit pouvoir vous donner une trame utilisable.

[jojodu71]

Merci beaucoup, je peux partager mon code ainsi que celui du capteur LDR. Je les compile dans un fichier Excel car mon code est long. C’est un code que j’ai réalisé avec l’aide de ChatGpt, et il n’est pas forcément simple.

[jojodu71]

voici le code
merci d'avance

[jojodu71]

Je vous joins également une vidéo montrant le principe du jeu

[jojodu71]

J’ai oublié de préciser, que sur mon code les lignes concernants les capteurs d’origine sont en jaune. Merci
Cordialement

[Jay M]

Très jolie réalisation - ça fait super propre ! bravo.

Pouvez vous zipper le .ino et ne pas l'envoyer en excel? (edit)

pouvez vous préciser quel arduino vous utilisez et joindre un dessin du circuit ?

Sur la vidéo on voit un trou rouge, cinq trous jaunes et des trous bleus et dans votre code on dirait que pour avancer il n'y a que 4 capteurs ?

pouvez vous expliquer comment est conçue la neomatrice ? je suppose que c'est pour l'affichage d'un N° qu'on voit en bleu rouge ou vert. est-ce que ça correspond à la place de l'escargot dans la course ou juste le N° de la piste de jeu dans la couleur de son escargot ?

EDIT

j'ai réussi à extraire le code - je le mets pour référence

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
176
177
 
// Code Escargot V4
#include <AccelStepper.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_GFX.h>
#include <Adafruit_NeoPixel.h>
 
#define NUM_PISTES 4
#define MATRIX_WIDTH 8
#define MATRIX_HEIGHT 8
#define MATRICE_PIN_1 24
#define MATRICE_PIN_2 27
#define MATRICE_PIN_3 30
#define MATRICE_PIN_4 33
#define NUM_LEDS 28
 
const int bcdPins_roue[4] = {14, 15, 16, 17};
 
const int LED_PINS[NUM_PISTES][2] = {
  {22, 23},
  {25, 26},
  {28, 29},
  {31, 32}
};
 
uint32_t colors[NUM_PISTES];
uint32_t originalColors[NUM_PISTES][2];
int brightnessMatrix = 200;
 
Adafruit_NeoMatrix matrices[NUM_PISTES] = {
  Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_1, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE),
  Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_2, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE),
  Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_3, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE),
  Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_4, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE)
};
 
const uint8_t numbers[NUM_PISTES][MATRIX_HEIGHT] = {
  {0b00011000,0b00111000,0b00011000,0b00011000,0b00011000,0b00011000,0b00111100,0b00000000},
  {0b00111100,0b01100110,0b00000110,0b00001100,0b00011000,0b00110000,0b01111110,0b00000000},
  {0b00111100,0b01100110,0b00000110,0b00011100,0b00000110,0b01100110,0b00111100,0b00000000},
  {0b00001100,0b00011100,0b00101100,0b01001100,0b01111110,0b00001100,0b00001100,0b00000000}
};
 
void setPixel(int matrixIndex, int x, int y, uint32_t color) {
  if (x >= 0 && x < MATRIX_WIDTH && y >= 0 && y < MATRIX_HEIGHT) {
    matrices[matrixIndex].drawPixel(x, y, color);
  }
}
 
void displayNumber(int matrixIndex) {
  matrices[matrixIndex].clear();
  for (int y = 0; y < MATRIX_HEIGHT; y++) {
    for (int x = 0; x < MATRIX_WIDTH; x++) {
      int invertedY = MATRIX_HEIGHT - 1 - y;
      int invertedX = MATRIX_WIDTH - 1 - x;
      if (numbers[matrixIndex][y] & (1 << (MATRIX_WIDTH - 1 - x))) {
        setPixel(matrixIndex, invertedX, invertedY, colors[matrixIndex]);
      } else {
        setPixel(matrixIndex, invertedX, invertedY, 0);
      }
    }
  }
  matrices[matrixIndex].show();
}
 
AccelStepper moteurs[] = {
  AccelStepper(AccelStepper::DRIVER, 46, 45),
  AccelStepper(AccelStepper::DRIVER, 48, 47),
  AccelStepper(AccelStepper::DRIVER, 50, 49),
  AccelStepper(AccelStepper::DRIVER, 52, 51)
};
 
const int ENABLE_PIN[4] = {54, 55, 56, 57};
const int LED_PIN_VERTE = 53;
 
int valeur1, valeur2, valeur3;
const int boutonDCY = 44;
const int boutonRetourArriere = 59;
 
const int switchFinCourseAvance[4] = {35, 37, 39, 41};
const int switchFinCourseRecule[4] = {36, 38, 40, 42};
 
const int capteursAvancer1[4] = {2, 5, 8, 11};
const int capteursAvancer2[4] = {3, 6, 9, 12};
const int capteursAvancer3[4] = {4, 7, 10, 13};
 
#define DUREE_SCINTILL_LED 5000
#define INTERVAL_SCINTILL_LED 30
#define NOMBRE_SCINTILL_LED 8
 
class LEDStrip {
public:
  Adafruit_NeoPixel strip1;
  Adafruit_NeoPixel strip2;
  uint32_t backgroundColor;
  uint8_t brightness1;
  uint8_t brightness2;
 
  LEDStrip(int pin1, int pin2, uint32_t bgColor, uint8_t b1, uint8_t b2)
    : strip1(NUM_LEDS, pin1, NEO_GRB + NEO_KHZ800),
      strip2(NUM_LEDS, pin2, NEO_GRB + NEO_KHZ800),
      backgroundColor(bgColor),
      brightness1(b1),
      brightness2(b2) {}
 
  void begin() {
    strip1.begin();
    strip2.begin();
    strip1.setBrightness(brightness1);
    strip2.setBrightness(brightness2);
    setAllColor(backgroundColor);
  }
 
  void setAllColor(uint32_t color) {
    for (int i = 0; i < NUM_LEDS; i++) {
      strip1.setPixelColor(i, color);
      strip2.setPixelColor(i, color);
    }
    strip1.show();
    strip2.show();
  }
};
 
LEDStrip pistes[NUM_PISTES] = {
  LEDStrip(22, 23, Adafruit_NeoPixel::Color(0,0,255), 200, 200),
  LEDStrip(25, 26, Adafruit_NeoPixel::Color(255,0,0), 200, 200),
  LEDStrip(28, 29, Adafruit_NeoPixel::Color(0,255,0), 200, 200),
  LEDStrip(31, 32, Adafruit_NeoPixel::Color(255,0,255), 200, 200)
};
 
bool enMouvement[4] = {false,false,false,false};
bool moteurEnRetourArriere[4] = {false,false,false,false};
bool cycleLance = false;
 
void updateMovementValues() {
  int valeurRoue = 0;
  for (int i = 0; i < 4; i++) {
    if (digitalRead(bcdPins_roue[i]) == LOW) valeurRoue |= (1 << i);
  }
  int nombrePas = valeurRoue * 100;
  valeur1 = -nombrePas * 2;
  valeur2 = -nombrePas * 4;
  valeur3 = -nombrePas * 6;
}
 
void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 4; i++) pinMode(bcdPins_roue[i], INPUT_PULLUP);
  for (int i = 0; i < NUM_PISTES; i++) pistes[i].begin();
  pinMode(LED_PIN_VERTE, OUTPUT);
  digitalWrite(LED_PIN_VERTE, LOW);
 
  colors[0] = matrices[0].Color(0,0,255);
  colors[1] = matrices[1].Color(255,0,0);
  colors[2] = matrices[2].Color(0,255,0);
  colors[3] = matrices[3].Color(255,0,255);
 
  updateMovementValues();
 
  for (int i = 0; i < NUM_PISTES; i++) {
    matrices[i].begin();
    matrices[i].setBrightness(brightnessMatrix);
    displayNumber(i);
  }
 
  for (int i = 0; i < 4; i++) {
    pinMode(ENABLE_PIN[i], OUTPUT);
    digitalWrite(ENABLE_PIN[i], LOW);
  }
 
  pinMode(boutonDCY, INPUT_PULLUP);
  pinMode(boutonRetourArriere, INPUT_PULLUP);
}
 
void loop() {
  updateMovementValues();
}

[jojodu71]

Merci beaucoup Jay M pour avis pris le temps de me répondre. je vais essayé de vous expliquer le fonctionnement.
Le déplacement des escargots est réalisé par des moteur Nema17 et ses convertisseurs associés couplé à un système de poulies et courroies crantées qui déplace des chariots montés sur roulettes
Pour déplacer ces chariots ou sont fixés les escargots, il y a en effet trois valeurs de points, le rouge, le jaune et le bleu. le rouge fait avancer l'escargot de 3 pas, le jaune de 2 pas et le bleu de 1 pas.
le principe est un système de goulotte qui se déverse les une dans les autres avec pour chaque sortie de goulotte un capteur qui vient détecter le passage de la balle et qui vaut 1 pas.
Ainsi lorsque la balle tombe dans un trou bleu, la balle passe par la goulotte 1 et en sortant de cette goulotte coupe le faisceau 1. Cela déplace l'escargot de 1 pas. Pour la goulotte des 2 pas (trou jaune), la balle coupe le faisceau 2 (1 pas) en sortant de la goulotte 2 puis tombe dans la goulotte 1 et coupe à son tour le faisceau 1, ce qui fait 1 + 1 pas donc 2 pas. Enfin lorsque la balle tombe dans le trou rouge, elle empreinte la goulotte 3 (1 pas), puis tombe dans la goulotte 2 (1 pas) et enfin dans la goulotte 1 ( 1 pas), ce qui donne 1+1+1 soit 3 pas.
on utilise donc 3 capteurs par piste. comme il y a 4 pistes de jeu (avec possibilité d'extension) cela fait 12 capteurs de détection de balle
A cela on trouve deux switchs de fin de course avant et arrière par piste soit 8 switrchs. le switch de fin de course avant correspond à la ligne d 'arrivée de chacune des piste. une fois un de ces switch activé, la course s'arrête et fige les escargots dans leur position. plus aucun point n'est pris en compte dès que la ligne d'arrivée est franchi par un des escargot et plus aucun mouvement en avant ne fonctionne (sécurité). Le switch arrière arrête les escargots sur la ligne de départ et autorise le prochain départ cycle
Un bouton départ cycle (DCY) pour lancer le jeu associé à une led verte de cycle en cours. la led s'éteint lorsque la course est finie
Un bouton retour pour ramener tous les escargots en position de départ en vitesse rapide. Le bouton dois être maintenu jusqu'à ce que tout les escargots soient en position de départ.
on trouve aussi une roue codeuse qui permet de faire varier la valeur du pas moteur pour faire varier la vitesse de déplacement des escargots
J'ai également rajouter des fioritures pour l'esthétique à savoir deux rubans leds de chaque côté des pistes de jeu qui sont de la couleur de la piste ainsi qu'une matrice led pour afficher le numéro de la piste correspondant au numéro d'escargot et également de la couleur de la piste.
Un effet de scintillement des bandeaux leds et de la matrice s'active sur la piste du vainqueur de la course.
Enfin, il y a un effet de défilement, de led sur la piste à chaque fois qu’un joueur marque un point

Pour gérer tout cela j'utilise un Arduino méga 2560
Comme je ne m'y connais pas grand chose en programmation Arduino, je me suis fait aider de ChatGPT pour rediger des morceaux de code pour chacune des actions souhaitées que j'ai compiler ensuite en un seul code. C'est certainement pas optimum et un peu lourd, mais je n'ai pas les compétences pour l'instant pour faire plus simple. désolé
j'espère avoir été suffisamment explicite dans mes explications, mais si vous avez besoin d'autres explications, je me ferrais un plaisir de vous les communiquer.
j'essaierai de vous envoyer un pseudo schéma de l'ensemble ce soir
et je testerais votre code pour vous faire un retour
encore merci et à très vite

[jojodu71]

j'ai réussi à extraire le code - je le mets pour référence

Pourras-*tu m'expliquer les modifications que tu as apporté à ton code ? il a l'air beaucoup plus simple que le miens, est-il complet ?
Encore merci

[umfred]

Je pense qu'il a essayé d'extraire le code ton fichier excel.

Le remplacement n'est pas très dur en soit, mais ici avec les lasers tu as une valeur analogique à gérer au lieu d'une valeur numérique.
Tu auras 2 (ou 3) tables d'entier (*3) en plus de celle qui définit tes entrées capteurs: une pour les valeurs initiales (valeurs au repos des 4 capteurs) dans le setup, une pour les mesures des capteurs dans le loop, et éventuellement, une pour les tolérances.

Il faut changer le mode d'utilisation de tes entrées, puisque c'est de l'analogique maintenant (donc les pins notés A0 à A15)

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
// Déclaration des broches des capteurs  (par exemple)
const int capteursAvancer1[4] = {A2, A5, A8, A11}; // Capteurs pour avancer les moteurs (valeur1) (INPUT)
const int capteursAvancer2[4] = {A3, A6, A9, A12}; // Capteurs pour avancer les moteurs (valeur2) (INPUT)
const int capteursAvancer3[4] = {A4, A7, A10, A13}; // Capteurs pour avancer les moteurs (valeur3) (INPUT)
 
// tableaux de mémorisation des valeurs initiales (au repos)
int valInitCapteurs1[4];
int valInitCapteurs2[4];
int valInitCapteurs3[4];
// tableaux des valeurs mesurées
int valCapteurs1[4];
int valCapteurs2[4];
int valCapteurs3[4];
// tableaux des seuils (appelé Tolérance dans ton code exemple)
const int tolCapteurs1[4]={200,200,200,200};
const int tolCapteurs2[4]={200,200,200,200};
const int tolCapteurs3[4]={200,200,200,200};

Dans ton setup

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
    // Initialisation des broches des capteurs  
    for (int i = 0; i < 4; i++) {
        pinMode(capteursAvancer1[i], INPUT); // Capteur avec résistance de tirage interne  
        pinMode(capteursAvancer2[i], INPUT); // Capteur avec résistance de tirage interne  
        pinMode(capteursAvancer3[i], INPUT); // Capteur avec résistance de tirage interne  
    }
    // Initialisation des valeurs initiales des capteurs  
    for (int i = 0; i < 4; i++) {
        valInitCapteurs1[i]=analogRead(capteursAvancer1[i]); 
        valInitCapteurs2[i]=analogRead(capteursAvancer2[i]); 
        valInitCapteurs3[i]=analogRead(capteursAvancer3[i]); 
    }

dans le loop (à ajuster le sens du signe et les valeurs de "tolérance" définie, mais ce serait l'idée en se basant sur ton code exemple de gestion des lasers)

Code :

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

1
2
3
4
5
 
valCapteurs1[i]=analogRead(capteurAvancer1[i]);
if(valCapteurs1[i] < valInitCapteurs1[i] - tolCapteurs1[i]){
...
}

[Jay M]

[B]
Pourras-*tu m'expliquer les modifications que tu as apporté à ton code ? il a l'air beaucoup plus simple que le miens, est-il complet ?
Encore merci

Si ce n'est pas le bon code, c'est que j'ai raté le copier coller pour extraire tout cela d'excel...

Pouvez vous poster le bon code?

sinon j'ai bien compris le fonctionnement, c'est malin l'idée des goulottes pour minimiser le nombre de capteurs.

[jojodu71]

Merci beaucoup pour cette réponse, mais c'est là que ça se complique
Si je pense comprendre les deux premières parties du code, c'est dans la partie loop où je n'arrive pas à comprendre comment rédiger le code pour que la comparaison puisse commander la rotation du moteur.
Dans l'exemple du laser, il allume une led, là je dois gérer les commandes des différents moteurs ! Je suis perdu
De plus, je vais devoir revoir tout mon câblage pour assigner les capteurs aux entrées analogiques de 2 à 13. je vais déjà commencer par ça !
merci pour tout

[jojodu71]

c'est malin l'idée des goulottes pour minimiser le nombre de capteurs.

Malin oui, mais compliquer à gérer, en tout cas pour moi. j'essai de vous envoyer le code ce soir
merci beaucoup

[umfred]

ça ne change rien à ton principe à toi, seule la condition est à modifier (ajuster les seuils par exemple pour avoir la bonne sensibilité de déclenchement (ne sachant pas le contexte du code exemple que tu as donné).

pour jay M (et les autres), le code complet du fichier excel: (il suffit de sélectionner la colonne B dans Excel et de le copier/coller dans notepad (par exemple) et supprimer les lignes inutiles à la fin

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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
// Code Escargot V4  
#include <AccelStepper.h> // Inclusion de la bibliothèque pour contrôler les moteurs pas à pas  
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_GFX.h>
#include <Adafruit_NeoPixel.h>
 
// Configuration des paramètres  
#define NUM_PISTES 4           // Nombre de matrices LED  
#define MATRIX_WIDTH 8         // Largeur d'une matrice LED  
#define MATRIX_HEIGHT 8        // Hauteur d'une matrice LED  
#define MATRICE_PIN_1 24       // Pin pour la première matrice  
#define MATRICE_PIN_2 27       // Pin pour la deuxième matrice  
#define MATRICE_PIN_3 30       // Pin pour la troisième matrice  
#define MATRICE_PIN_4 33       // Pin pour la quatrième matrice  
#define NUM_LEDS 28            // Nombre de LEDs par ruban 
 
// Déclaration des broches de la roue codeuse BCD  
const int bcdPins_roue[4] = {14, 15, 16, 17}; // Broches connectées à la roue codeuse
 
// Définition des broches des rubans LED  
const int LED_PINS[NUM_PISTES][2] = {
    {22, 23}, // Piste 1 : Ruban 1 sur pin 22, Ruban 2 sur pin 23 
    {25, 26}, // Piste 2 : Ruban 1 sur pin 25, Ruban 2 sur pin 26 
    {28, 29}, // Piste 3 : Ruban 1 sur pin 28, Ruban 2 sur pin 29 
    {31, 32}  // Piste 4 : Ruban 1 sur pin 31, Ruban 2 sur pin 32 
};
 
// Définition des couleurs des matrices  
uint32_t colors[NUM_PISTES]; // Tableau pour stocker les couleurs des matrices  
uint32_t originalColors[NUM_PISTES][2]; // Couleurs d'origine pour les rubans LED  
int brightnessMatrix = 200; // Luminosité par défaut pour toutes les matrices
 
// Création des matrices LED  
Adafruit_NeoMatrix matrices[NUM_PISTES] = {
    Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_1, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE),
    Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_2, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE),
    Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_3, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE),
    Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT, MATRICE_PIN_4, NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE)
};
 
// Définition des chiffres à afficher sur les matrices  
const uint8_t numbers[NUM_PISTES][MATRIX_HEIGHT] = {
    {0b00011000, 0b00111000, 0b00011000, 0b00011000, 0b00011000, 0b00011000, 0b00111100, 0b00000000}, // 1  
    {0b00111100, 0b01100110, 0b00000110, 0b00001100, 0b00011000, 0b00110000, 0b01111110, 0b00000000}, // 2  
    {0b00111100, 0b01100110, 0b00000110, 0b00011100, 0b00000110, 0b01100110, 0b00111100, 0b00000000}, // 3  
    {0b00001100, 0b00011100, 0b00101100, 0b01001100, 0b01111110, 0b00001100, 0b00001100, 0b00000000}  // 4  
};
 
// Fonction pour afficher un chiffre sur la matrice  
void displayNumber(int matrixIndex) {
    matrices[matrixIndex].clear(); // Nettoyer la matrice  
    for (int y = 0; y < MATRIX_HEIGHT; y++) {
        for (int x = 0; x < MATRIX_WIDTH; x++) {
            // Inverser l'axe Y pour afficher correctement le chiffre  
            int invertedY = MATRIX_HEIGHT - 1 - y; 
            int invertedX = MATRIX_WIDTH - 1 - x; 
 
            // Vérifie si le bit est allumé pour allumer la LED correspondante  
            if (numbers[matrixIndex][y] & (1 << (MATRIX_WIDTH - 1 - x))) { 
                setPixel(matrixIndex, invertedX, invertedY, colors[matrixIndex]); // Allume la LED en couleur  
            } else {
                setPixel(matrixIndex, invertedX, invertedY, 0); // Éteint la LED  
            }
        }
    }
    matrices[matrixIndex].show(); // Met à jour la matrice avec les nouvelles couleurs  
}
 
// Fonction pour définir la couleur d'un pixel dans la matrice  
void setPixel(int matrixIndex, int x, int y, uint32_t color) {
    if (x >= 0 && x < MATRIX_WIDTH && y >= 0 && y < MATRIX_HEIGHT) { // Vérifie que les coordonnées sont valides  
        matrices[matrixIndex].drawPixel(x, y, color); // Définit la couleur du pixel  
    }
}
 
// Définition et initialisation des moteurs  
AccelStepper moteurs[] = {
    AccelStepper(AccelStepper::DRIVER, 46, 45),
    AccelStepper(AccelStepper::DRIVER, 48, 47),
    AccelStepper(AccelStepper::DRIVER, 50, 49),
    AccelStepper(AccelStepper::DRIVER, 52, 51)
};
 
// Broche pour activer ou désactiver les drivers TB6600  
const int ENABLE_PIN[4] = {54, 55, 56, 57};
 
// Broche pour la LED Verte 
const int LED_PIN_VERTE = 53; // Broche de la LED verte
 
// Paramètres des moteurs  
float nombrePas; 
int valeur1, valeur2, valeur3; // Valeurs de mouvement  
const float DEGRES_PAR_PAS[4] = {0.9, 0.9, 0.9, 0.9};  // Angle par pas 
const int MICRO_PAS[4] = {2, 2, 2, 2}; // Réglage du micro-pas pour le driver  
float rotation_moteur[4] = {360, 360, 360, 360}; // Rotation souhaitée en degrés  
int vitesse_moteur[4] = {2000, 2000, 2000, 2000}; // Vitesse maximale en pas/seconde  
int acceleration_moteur[4] = {1500, 1500, 1500, 1500}; // Accélération en pas/seconde²  
 
// Déclaration des boutons  
const int boutonDCY = 44; // bouton utilisé pour lancer le cycle  
const int boutonRetourArriere = 59; // bouton utilisé pour inverser le sens des moteurs
 
// Déclaration des broches des interrupteurs de fin de course  
const int switchFinCourseAvance[4] = {35, 37, 39, 41}; // Fin de course pour avancer (INPUT_PULLUP)  
const int switchFinCourseRecule[4] = {36, 38, 40, 42}; // Fin de course pour reculer (INPUT_PULLUP)
 
// Déclaration des broches des capteurs  
const int capteursAvancer1[4] = {2, 5, 8, 11}; // Capteurs pour avancer les moteurs (valeur1) (INPUT)
const int capteursAvancer2[4] = {3, 6, 9, 12}; // Capteurs pour avancer les moteurs (valeur2) (INPUT)
const int capteursAvancer3[4] = {4, 7, 10, 13}; // Capteurs pour avancer les moteurs (valeur3) (INPUT)
 
// ---- Variables pour le scintillement ----  
#define DUREE_SCINTILL_LED 5000  // Durée du scintillement en millisecondes 
#define INTERVAL_SCINTILL_LED 30  // Intervalle entre les scintillements 
#define NOMBRE_SCINTILL_LED  8     // Nombre de LEDs à faire scintiller aléatoirement à la fois
 
// Variables pour le scintillement  
unsigned long blinkDuration = 5000; // Durée de scintillement en millisecondes  
unsigned long blinkSpeed = 20; // Vitesse du scintillement (intervalle entre les LED) en millisecondes  
int ledCount = 8; // Nombre de LEDs à faire scintiller simultanément  
 
// ---- Classe pour gérer les rubans LED ----  
class LEDStrip {
public:
    Adafruit_NeoPixel strip1;  // Premier ruban LED 
    Adafruit_NeoPixel strip2;  // Deuxième ruban LED 
 
    // Couleur et luminosité  
    uint32_t backgroundColor;   // Couleur de fond 
    uint8_t brightness1;         // Luminosité pour le ruban 1 
    uint8_t brightness2;         // Luminosité pour le ruban 2 
 
    // Constructeur pour initialiser le ruban LED 
    LEDStrip(int pin1, int pin2, uint32_t bgColor, uint8_t bright1, uint8_t bright2)
        : strip1(NUM_LEDS, pin1, NEO_GRB + NEO_KHZ800), 
          strip2(NUM_LEDS, pin2, NEO_GRB + NEO_KHZ800), 
          backgroundColor(bgColor), 
          brightness1(bright1), 
          brightness2(bright2) {}
 
    // Méthode d'initialisation du ruban LED  
    void begin() {
        strip1.begin();
        strip2.begin();
        strip1.setBrightness(brightness1); // Appliquer la luminosité pour le ruban 1 
        strip2.setBrightness(brightness2); // Appliquer la luminosité pour le ruban 2 
        setAllColor(backgroundColor); // Afficher immédiatement la couleur de fond 
    }
 
    // Méthode pour définir la couleur de toutes les LEDs des deux rubans  
    void setAllColor(uint32_t color) {
        for (int i = 0; i < NUM_LEDS; i++) {
            strip1.setPixelColor(i, color);
            strip2.setPixelColor(i, color);
        }
        strip1.show();
        strip2.show();
    }
};
 
// ---- Initialisation des pistes avec couleur de fond et luminosité ----  
LEDStrip pistes[NUM_PISTES] = {
    LEDStrip(LED_PINS[0][0], LED_PINS[0][1], Adafruit_NeoPixel::Color(0, 0, 255), 200, 200), // Piste 1 : Couleur de fond bleue  
    LEDStrip(LED_PINS[1][0], LED_PINS[1][1], Adafruit_NeoPixel::Color(255, 0, 0), 200, 200), // Piste 2 : Couleur de fond rouge  
    LEDStrip(LED_PINS[2][0], LED_PINS[2][1], Adafruit_NeoPixel::Color(0, 255, 0), 200, 200), // Piste 3 : Couleur de fond verte  
    LEDStrip(LED_PINS[3][0], LED_PINS[3][1], Adafruit_NeoPixel::Color(255, 0, 255), 200, 200)  // Piste 4 : Couleur de fond magenta  
};
 
// Variables pour les boutons  
bool boutonRetourArriereEtatPrecedent = HIGH;
 
// Variables pour les capteurs  
bool moteurEnRetourArriere[4] = {false, false, false, false};
 
// État des mouvements pour chaque moteur  
bool enMouvement[4] = {false, false, false, false}; 
int mouvements[4] = {0, 0, 0, 0}; // Valeurs de mouvement en attente pour chaque moteur  
bool cycleLance = false; // État du cycle
 
// Variables pour suivre l'état des interrupteurs de fin de course  
bool finCourseEtatPrecedent[4] = {HIGH, HIGH, HIGH, HIGH}; // État précédent de chaque interrupteur  
bool finCourseAvantEtatActuel[4] = {HIGH, HIGH, HIGH, HIGH}; // État actuel des interrupteurs
 
// ============================
// FONCTION SETUP  
// ============================
void setup() {
    Serial.begin(9600); // Initialisation de la communication série pour débogage
 
    // Initialisation des broches de la roue codeuse  
    for (int i = 0; i < 4; i++) {
        pinMode(bcdPins_roue[i], INPUT_PULLUP); // Configurer les broches de la roue codeuse en entrée avec tirage interne  
    }
 
    // Initialisation des pistes LED  
    for (int i = 0; i < NUM_PISTES; i++) {
        pistes[i].begin(); // Initialiser chaque ruban LED 
    }
 
    // Initialiser la broche de la LED Verte 
    pinMode(LED_PIN_VERTE, OUTPUT);
    digitalWrite(LED_PIN_VERTE, LOW); // Éteindre la LED par défaut
 
    // Initialisation des couleurs pour les chiffres  
    colors[0] = matrices[0].Color(0, 0, 255);    // Bleu pour le chiffre 1  
    colors[1] = matrices[1].Color(255, 0, 0);    // Rouge pour le chiffre 2  
    colors[2] = matrices[2].Color(0, 255, 0);    // Vert pour le chiffre 3  
    colors[3] = matrices[3].Color(255, 0, 255);  // Violet pour le chiffre 4
 
    // Initialisation des valeurs de déplacement  
    updateMovementValues(); // Mettre à jour les valeurs de mouvement initiales
 
    // Initialisation des matrices LED  
    for (int i = 0; i < NUM_PISTES; i++) {
        matrices[i].begin(); // Initialiser la matrice  
        matrices[i].setTextWrap(false); // Désactiver l'enroulement du texte  
        matrices[i].setBrightness(brightnessMatrix); // Définir la luminosité commune  
        matrices[i].clear(); // Nettoyer la matrice  
        matrices[i].show(); // Afficher l'état initial
 
        // Afficher le numéro correspondant à la matrice  
        displayNumber(i); // Afficher le numéro immédiatement après l'initialisation  
    }
 
    // Configuration de la broche ENABLE en sortie  
    for (int i = 0; i < 4; i++) {
        pinMode(ENABLE_PIN[i], OUTPUT);
        digitalWrite(ENABLE_PIN[i], LOW);  // Désactiver par défaut  
        moteurs[i].setMaxSpeed(vitesse_moteur[i]); // Vitesse max pour chaque moteur  
        moteurs[i].setAcceleration(acceleration_moteur[i]); // Accélération pour chaque moteur  
    }
 
    // Initialisation des broches des capteurs  
    for (int i = 0; i < 4; i++) {
        pinMode(capteursAvancer1[i], INPUT); // Capteur avec résistance de tirage interne  
        pinMode(capteursAvancer2[i], INPUT); // Capteur avec résistance de tirage interne  
        pinMode(capteursAvancer3[i], INPUT); // Capteur avec résistance de tirage interne  
    }
 
    // Initialisation des broches des boutons  
    pinMode(boutonDCY, INPUT_PULLUP); // Bouton avec résistance de tirage externe  
    pinMode(boutonRetourArriere, INPUT_PULLUP); // Bouton avec résistance de tirage externe
 
    // Initialisation des broches des Switchs  
    for (int i = 0; i < 4; i++) {
        pinMode(switchFinCourseAvance[i], INPUT_PULLUP); // Switch avec résistance de tirage externe  
        pinMode(switchFinCourseRecule[i], INPUT_PULLUP); // Switch avec résistance de tirage externe  
    }
 
    Serial.println("Programme démarré");
}
 
// Fonction pour mettre à jour les valeurs de déplacement en fonction de la roue codeuse  
void updateMovementValues() {
    // Lecture de la valeur de la roue codeuse BCD  
    int valeurRoue = 0;
    for (int i = 0; i < 4; i++) {
        if (digitalRead(bcdPins_roue[i]) == LOW) {
            valeurRoue |= (1 << i); // Lire la valeur BCD  
        }
    }
    int nombrePas = valeurRoue * 100; // Calculer le nombre de pas à déplacer  
 
    // Calculer les valeurs  
    valeur1 = -nombrePas * 2; // Valeur pour les trous bleus  
    valeur2 = -nombrePas * 4; // Valeur pour les trous jaunes  
    valeur3 = -nombrePas * 6; // Valeur pour les trous rouges  
}
 
// ============================
// FONCTION POUR FAIRE SCINTILLER LES LEDs  
// ============================
void scintillerLED(int index) {
    unsigned long startTime = millis(); // Enregistrer le temps de début du scintillement  
    unsigned long currentTime;
 
    // Scintille les LEDs pendant la durée spécifiée  
    while (true) {
        currentTime = millis();
        if (currentTime - startTime > DUREE_SCINTILL_LED) {
            break; // Sortir de la boucle après la durée  
        }
 
        // Faire scintiller les rubans LED  
        for (int i = 0; i < NOMBRE_SCINTILL_LED; i++) {
            int ledIndex = random(NUM_LEDS); // Choisir une LED aléatoire  
            pistes[index].strip1.setPixelColor(ledIndex, Adafruit_NeoPixel::Color(255, 255, 255)); // LED blanche  
            pistes[index].strip2.setPixelColor(ledIndex, Adafruit_NeoPixel::Color(255, 255, 255)); // LED blanche  
        }
        pistes[index].strip1.show();
        pistes[index].strip2.show();
 
        // Faire scintiller la matrice LED  
        for (int i = 0; i < ledCount; i++) {
            int ledIndex = random(MATRIX_WIDTH * MATRIX_HEIGHT); // Choisir une LED aléatoire dans la matrice  
            int x = ledIndex % MATRIX_WIDTH;
            int y = ledIndex / MATRIX_WIDTH;
            matrices[index].drawPixel(x, y, matrices[index].Color(255, 255, 255)); // LED blanche  
        }
        matrices[index].show();
 
        delay(INTERVAL_SCINTILL_LED); // Attendre l'intervalle de scintillement
 
        // Éteindre les LEDs  
        for (int i = 0; i < NOMBRE_SCINTILL_LED; i++) {
            int ledIndex = random(NUM_LEDS); // Choisir une autre LED aléatoire  
            pistes[index].strip1.setPixelColor(ledIndex, 0); // Éteindre  
            pistes[index].strip2.setPixelColor(ledIndex, 0); // Éteindre  
        }
 
        // Éteindre la matrice LED  
        for (int i = 0; i < ledCount; i++) {
            int ledIndex = random(MATRIX_WIDTH * MATRIX_HEIGHT); // Choisir une LED aléatoire dans la matrice  
            int x = ledIndex % MATRIX_WIDTH;
            int y = ledIndex / MATRIX_WIDTH;
            matrices[index].drawPixel(x, y, 0); // Éteindre  
        }
        pistes[index].strip1.show();
        pistes[index].strip2.show();
        matrices[index].show();
    }
 
    // Remettre les LEDs dans leur état d'origine  
    pistes[index].setAllColor(pistes[index].backgroundColor); // Remettre la couleur d'origine pour le ruban  
    matrices[index].clear(); // Nettoyer la matrice  
    displayNumber(index); // Réafficher le numéro de la piste  
}
 
// ============================
// FONCTION LOOP  
// ============================
void loop() {
    // Vérification de l'état du boutonDCY pour lancer le cycle  
    bool boutonDCYEtat = digitalRead(boutonDCY);
    static bool dernierEtatBoutonDCY = HIGH; // Variable pour suivre le dernier état du bouton  
    static bool moteurDegage = false; // État pour contrôler si les moteurs ont été dégagés  
    static bool scintillementActif = false; // État pour contrôler si le scintillement a déjà eu lieu
 
    // Mise à jour des valeurs de mouvement en fonction de la roue codeuse  
    updateMovementValues();
 
    // Gestion du cycle  
    if (dernierEtatBoutonDCY == HIGH && boutonDCYEtat == LOW && !moteurDegage) {
        // Si le bouton DCY est pressé, déplacer tous les moteurs de 100 pas  
        Serial.println("Déplacement des moteurs pour dégager les interrupteurs arrière.");
 
        // Définir la vitesse et l'accélération pour ce mouvement  
        for (int i = 0; i < 4; i++) {
            moteurs[i].setMaxSpeed(2000); // Définir la vitesse pour ce mouvement  
            moteurs[i].setAcceleration(1500); // Définir l'accélération pour ce mouvement  
            digitalWrite(ENABLE_PIN[i], HIGH); // Activer le moteur  
            moteurs[i].move(-100); // Déplacer chaque moteur de 100 pas  
        }
        moteurDegage = true; // Indiquer que les moteurs ont été dégagés  
        scintillementActif = false; // Réinitialiser l'état du scintillement  
    }
 
    // Activer le cycle une fois que les moteurs ont été déplacés  
    if (moteurDegage) {
        // Vérifiez si tous les moteurs ont terminé leur déplacement  
        bool tousMouvementsTermines = true;
        for (int i = 0; i < 4; i++) {
            // Exécuter le mouvement jusqu'à ce que tous les moteurs aient terminé leur déplacement  
            moteurs[i].run(); // Exécuter le mouvement
 
            if (moteurs[i].distanceToGo() != 0) {
                tousMouvementsTermines = false; // Si un moteur est encore en mouvement  
            }
        }
 
        // Si tous les moteurs ont terminé leur mouvement, commencer le cycle  
        if (tousMouvementsTermines) {
            moteurDegage = false; // Réinitialiser l'état  
            Serial.println("Cycle lancé !");
            digitalWrite(LED_PIN_VERTE, HIGH); // Allumer la LED verte  
            cycleLance = true; // Activer le cycle  
        } else {
            // Si un moteur est encore en mouvement, désactiver l'ENABLE une fois la distance atteinte  
            for (int i = 0; i < 4; i++) {
                if (moteurs[i].distanceToGo() == 0) {
                    digitalWrite(ENABLE_PIN[i], LOW); // Désactiver le moteur  
                }
            }
        }
    }
 
    // Vérification des interrupteurs de fin de course avant  
    for (int i = 0; i < 4; i++) {
        // Lire l'état actuel des switchs  
        finCourseAvantEtatActuel[i] = digitalRead(switchFinCourseAvance[i]); // Switch avant  
 
        // Vérifiez si l'état des switchs avant a changé pour détecter le front montant  
        if (finCourseAvantEtatActuel[i] == LOW && finCourseEtatPrecedent[i] == HIGH && cycleLance && !scintillementActif) {
            cycleLance = false; // Désactiver le cycle  
            digitalWrite(LED_PIN_VERTE, LOW); // Éteindre la LED  
            for (int j = 0; j < 4; j++) {
                moteurs[j].stop(); // Arrêter tous les moteurs  
                moteurs[j].setCurrentPosition(0); // Réinitialiser la position du moteur  
            }
            Serial.println("Fin de course avant activée, cycle arrêté !");
            scintillerLED(i); // Appelle la fonction de scintillement pour le ruban et la matrice correspondants  
            scintillementActif = true; // Marquer que le scintillement a eu lieu  
        }
 
        // Mettez à jour l'état précédent  
        finCourseEtatPrecedent[i] = finCourseAvantEtatActuel[i];
    }
 
    // Vérifier si le cycle est lancé  
    if (cycleLance) {
        for (int i = 0; i < 4; i++) {
            // Vérifiez si le moteur est déjà en mouvement  
            if (!enMouvement[i]) {
                // Déterminer le mouvement à effectuer  
                if (digitalRead(capteursAvancer1[i]) == LOW) {
                    Serial.print("Moteur ");
                    Serial.print(i + 1);
                    Serial.println(" avance de valeur1.");
                    moteurs[i].move(valeur1); // Déplacer le moteur  
                    enMouvement[i] = true; // Indique que le moteur est en mouvement  
                    digitalWrite(ENABLE_PIN[i], HIGH); // Activer le moteur  
                } else if (digitalRead(capteursAvancer2[i]) == LOW) {
                    Serial.print("Moteur ");
                    Serial.print(i + 1);
                    Serial.println(" avance de valeur2.");
                    moteurs[i].move(valeur2); // Déplacer le moteur  
                    enMouvement[i] = true; // Indique que le moteur est en mouvement  
                    digitalWrite(ENABLE_PIN[i], HIGH); // Activer le moteur  
                } else if (digitalRead(capteursAvancer3[i]) == LOW) {
                    Serial.print("Moteur ");
                    Serial.print(i + 1);
                    Serial.println(" avance de valeur3.");
                    moteurs[i].move(valeur3); // Déplacer le moteur  
                    enMouvement[i] = true; // Indique que le moteur est en mouvement  
                    digitalWrite(ENABLE_PIN[i], HIGH); // Activer le moteur  
                }
            }
 
            // Exécuter le mouvement s'il y a un mouvement à effectuer  
            if (enMouvement[i]) {
                moteurs[i].run(); // Exécuter le mouvement
 
                // Vérifier si le mouvement est terminé  
                if (moteurs[i].distanceToGo() == 0) {
                    enMouvement[i] = false; // Réinitialiser l'état de mouvement  
                    digitalWrite(ENABLE_PIN[i], LOW); // Désactiver le moteur  
                    Serial.print("Moteur ");
                    Serial.print(i + 1);
                    Serial.println(" a terminé son mouvement.");
                }
            }
        }
    }
 
    // Gestion du bouton pour le retour arrière  
    bool boutonRetourArriereEtat = digitalRead(boutonRetourArriere);
    static bool dernierEtatBoutonRetourArriere = HIGH; // Pour suivre l'état précédent du bouton
 
    // Détecter une impulsion sur le bouton de retour arrière  
    if (dernierEtatBoutonRetourArriere == HIGH && boutonRetourArriereEtat == LOW) {
        // Activer le retour arrière pour tous les moteurs  
        for (int i = 0; i < 4; i++) {
            moteurEnRetourArriere[i] = true; // Activer le retour arrière  
            digitalWrite(ENABLE_PIN[i], HIGH); // Activer le moteur  
        }
        Serial.println("Recul activé pour les quatre moteurs.");
        delay(200); // Petite pause pour stabilisation  
    }
 
    // Gérer la désactivation du mouvement après une impulsion  
    if (dernierEtatBoutonRetourArriere == LOW && boutonRetourArriereEtat == HIGH) {
        for (int i = 0; i < 4; i++) {
            moteurEnRetourArriere[i] = false; // Désactiver le retour arrière  
            moteurs[i].stop(); // Arrêter tous les moteurs  
            digitalWrite(ENABLE_PIN[i], LOW); // Désactiver le moteur  
        }
        Serial.println("Recul arrêté pour les quatre moteurs.");
        delay(200); // Petite pause pour stabilisation  
    }
 
    // Mettre à jour l'état précédent du bouton de retour arrière  
    dernierEtatBoutonRetourArriere = boutonRetourArriereEtat;
 
    // Gestion du mouvement en arrière  
    for (int i = 0; i < 4; i++) {
        if (moteurEnRetourArriere[i]) {
            // Vérifiez si l'interrupteur de fin de course arrière est activé  
            if (digitalRead(switchFinCourseRecule[i]) == LOW) {
                moteurEnRetourArriere[i] = false; // Désactiver le retour arrière  
                moteurs[i].stop(); // Arrêter le moteur  
                digitalWrite(ENABLE_PIN[i], LOW); // Désactiver le moteur  
                Serial.print("Recul arrêté pour le moteur ");
                Serial.println(i + 1);
            } else {
                moteurs[i].setSpeed(2000); // Utiliser une vitesse positive pour le recul  
                moteurs[i].runSpeed(); // Exécuter le mouvement en arrière  
            }
        }
    }
 
    // Mettre à jour l'état précédent du bouton DCY  
    dernierEtatBoutonDCY = boutonDCYEtat; 
}

et le code donné en exemple pour les lasers:

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
#define ledPinrouge 3 // Définit le numéro de la broche pour la LED rouge (D3)
#define ledPinverte 4 // Définit le numéro de la broche pour la LED verte (D4)
#define sensorPin A0 // Définit la broche analogique utilisée pour le capteur (A0)
int SensorValue = 0; // Variable pour stocker la lecture actuelle du capteur
int SensorValueRepos; // Variable pour stocker la valeur de référence (au calme)
int Tolerancedetection = 200; // Seuil de sensibilité pour déclencher l'alerte
void setup() {
Serial.begin(9600); // Ouvre le port série pour afficher des données sur l'ordinateur
pinMode(ledPinrouge, OUTPUT); // Configure la broche 3 comme une sortie (envoie du courant)
pinMode(ledPinverte, OUTPUT); // Configure la broche 4 comme une sortie
// Lit la valeur du capteur au démarrage pour définir l'état au calme
SensorValueRepos = analogRead(sensorPin); 
}
void loop() {
SensorValue = analogRead(sensorPin); // Lit la valeur actuelle du capteur (entre 0 et 1023)
Serial.println(SensorValue); // Affiche la valeur dans le Moniteur Série
// CONDITION : Si la valeur actuelle est SIGNIFICATIVEMENT plus basse que la valeur au repos
if (SensorValue < SensorValueRepos - Tolerancedetection) {
digitalWrite(ledPinrouge, HIGH); // Allume la LED rouge (Alerte)
digitalWrite(ledPinverte, LOW); // Éteint la LED verte
} 
// SINON (si tout est normal)
else {
digitalWrite(ledPinverte, HIGH); // Allume la LED verte (OK)
digitalWrite(ledPinrouge, LOW); // Éteint la LED rouge
}
delay(50); // Attend 50 millisecondes avant la prochaine lecture pour stabiliser
}

[jojodu71]

Merci pour le partage des codes, ça va me faire gagner du temps

[jojodu71]

ça ne change rien à ton principe à toi, seule la condition est à modifier (ajuster les seuils par exemple pour avoir la bonne sensibilité de déclenchement (ne sachant pas le contexte du code exemple que tu as donné).
[/CODE]

Ah oui cool, les anciens capteurs étaient déjà branchés sur les bornes de 2 à 13, donc si j'ai bien compris, il faut juste changer l'assignation de 2 en A2 et idem pour les autres ?
merci

[Jay M]

pour jay M (et les autres), le code complet du fichier excel: (il suffit de sélectionner la colonne B dans Excel et de le copier/coller dans notepad (par exemple) et supprimer les lignes inutiles à la fin

je lisais cela sur mon iPhone - les PJ c'est galère

[Jay M]

j'ai remarqué dans le code

Code :

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

1
2
3
4
5
6
7
// Définition des broches des rubans LED
const int LED_PINS[NUM_PISTES][2] = {
  {22, 23}, // Piste 1 : Ruban 1 sur pin 22, Ruban 2 sur pin 23
  {25, 26}, // Piste 2 : Ruban 1 sur pin 25, Ruban 2 sur pin 26
  {28, 29}, // Piste 3 : Ruban 1 sur pin 28, Ruban 2 sur pin 29
  {31, 32}  // Piste 4 : Ruban 1 sur pin 31, Ruban 2 sur pin 32
};

mais je vois que ces bandeaux font toujours la même chose par le biais de votre class LEDStrip.
Y a-t-il une raison pour ne pas avoir simplement mis 1 seule broche vers les pins DIN des rubans ?
ça libère une broche par machine et ça simplifie le code et prend moins de mémoire.