Discussion :

[Fadiga Mohamed fode]

Bonjour cher aîné, voila mon programme d'affichage de vitesse de rotation dans le moniteur série de mon PC et ça fonctionne bien. j'aimerai passé du port Serie du PC au LCD 1602.

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
#include <TimerOne.h>
const byte Led_Builtin;
const byte Sensor = 2;
const byte Green_Led =12;
const byte Red_Led =8;
const byte relais =10;
 
volatile int cnt = 0;
volatile int revs = 0;
int speedLow = 500;
int speedHigh = 2000;
 
 
void ISR_pulse(){
  cnt++;
}
void ISR_timerone(){
  Timer1.detachInterrupt();
  Serial.print("Vitesse_moteur:");
  revs = (cnt*30.00);
  Serial.print(revs);
  Serial.println("RPM-");
  cnt = 0;
  Timer1.attachInterrupt(ISR_timerone);
}
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  pinMode(Led_Builtin,OUTPUT);
  digitalWrite(Led_Builtin, LOW); 
  pinMode(Green_Led,OUTPUT);
  pinMode(Red_Led,OUTPUT);
  pinMode(relais,OUTPUT);
  attachInterrupt(digitalPinToInterrupt(Sensor), ISR_pulse,RISING);
 
  Timer1.initialize (2000000);
  Timer1.attachInterrupt(ISR_timerone);
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
  if ( revs > speedLow){
    digitalWrite(Green_Led,HIGH);
  } else{
    digitalWrite(Green_Led,LOW);
  }
  if ( revs > speedHigh){
    digitalWrite(Red_Led,HIGH);
    digitalWrite(relais,HIGH);
  } else{
    digitalWrite(Red_Led,LOW);
    digitalWrite(relais,LOW);
  }
 
}

j'aimerai affiché cette vitesse sur mon écran LCD I2C. j'ai changé tout les Serials en LCD et quand je téléverse le programme et que je met le moteur en marche, rien ne s'affiche sur mon LCD. Alors je sollicite votre aide afin de résoudre mon problème.

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
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TimerOne.h>
LiquidCrystal_I2C lcd(0x27,16,2);
 
const byte Led_Builtin;
const byte Sensor = 2;
const byte Green_Led =12;
const byte Red_Led =8;
const byte relais =10;
 
volatile int cnt = 0;
volatile int revs = 0;
int speedLow = 500;
int speedHigh = 2000;
 
 
void ISR_pulse(){
  cnt++;
}
void ISR_timerone(){
  lcd.init();
  Timer1.detachInterrupt();
  lcd.backlight();
  lcd.setCursor(0,1);
  lcd.print("Vitesse_moteur:");
  lcd.setCursor(0,1);
  revs = (cnt*30.00);
  lcd.print(revs);
  lcd.println("RPM-");
  cnt = 0;
  Timer1.attachInterrupt(ISR_timerone);
}
void setup() {
  // put your setup code here, to run once:
  //lcd.begin();
  pinMode(Led_Builtin,OUTPUT);
  digitalWrite(Led_Builtin, LOW); 
  pinMode(Green_Led,OUTPUT);
  pinMode(Red_Led,OUTPUT);
  pinMode(relais,OUTPUT);
  attachInterrupt(digitalPinToInterrupt(Sensor), ISR_pulse,RISING);
 
  Timer1.initialize (2000000);
  Timer1.attachInterrupt(ISR_timerone);
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
  if ( revs > speedLow){
    digitalWrite(Green_Led,HIGH);
  } else{
    digitalWrite(Green_Led,LOW);
  }
  if ( revs > speedHigh){
    digitalWrite(Red_Led,HIGH);
    digitalWrite(relais,HIGH);
  } else{
    digitalWrite(Red_Led,LOW);
    digitalWrite(relais,LOW);
  }
 
}

merci !!!

[Fadiga Mohamed fode]

Bonjour, j'ai réussi à afficher le test sur mon LCD mais ma vitesse ne change (s'incrémente) pas et mon écran affiche [0RPM], je sollicite votre aide afin que je puisse voir la vitesse du moteur s'incrémenté.

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
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TimerOne.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
 
const byte Led_Builtin;
const byte Sensor = 2;
const byte Green_Led = 12;
const byte Red_Led = 8;
const byte relais = 10;
 
volatile int cnt = 0;
volatile int revs = 0;
int speedLow = 500;
int speedHigh = 2000;
 
 
void ISR_pulse() {
 cnt++;
}
void setup() {
  lcd.init();
  lcd.backlight();
  delay(1000);
  lcd.setCursor(0,0); 
  lcd.print("fadim");
  delay(1000);
  lcd.setCursor(2,1);
  lcd.print("fourche");
  delay(2000);
  lcd.clear();
  // put your setup code here, to run once:
//  lcd.begin();
  pinMode(Led_Builtin, OUTPUT);
  digitalWrite(Led_Builtin, LOW);
  pinMode(Green_Led, OUTPUT);
  pinMode(Red_Led, OUTPUT);
  pinMode(relais, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(Sensor), ISR_pulse, RISING);
 
  Timer1.initialize (2000000);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  //lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Vitesse_moteur:");
  lcd.setCursor(6, 1);
  revs = (cnt * 30.00);
  lcd.print(revs);
  lcd.println("RPM-");
  cnt = 0;
  if ( revs > speedLow) {
    digitalWrite(Green_Led, HIGH);
  } else {
    digitalWrite(Green_Led, LOW);
  }
  if ( revs > speedHigh) {
    digitalWrite(Red_Led, HIGH);
    digitalWrite(relais, HIGH);
  } else {
    digitalWrite(Red_Led, LOW);
    digitalWrite(relais, LOW);
  }
 
}

et aussi si tout va j'aimerai utilisé 3 LCD et 3 capteurs sur la même carte de arduino méga afin d'utiliser 1 arduino au lieux de 3 arduino. Chaque capteur a son LCD pour afficher ses propre infos.
Merci !!!

[paulli]

Je n'ai pas beaucoup utilisé le LCD 1602, j'ai un écran série et si c'était moi, j'utiliserais un seul écran pour afficher les valeurs de chacun des 3 capteurs.

[Guesset]

Bonjour,

Dans le premier code Timer1 est initialisé mais pas utilisé donc la boucle loop() tourne librement et remet cnt à 0 plus rapidement qu'il n'incrémente. Il doit y avoir un affichage 0RPM avec quelque fois un 30RPM fugitif. En fait Timer1 n'est pas nécessaire dans ce cas.

Code C++ :

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
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
 
const byte Led_Builtin;
const byte Sensor    = 2;
const byte Green_Led = 12;
const byte Red_Led   = 8;
const byte relais    = 10;
 
volatile int cnt     = 0;
volatile int revs    = 0;
const int speedLow   =  500;
const int speedHigh  = 2000;
unsigned long To;
 
void ISR_pulse() {  cnt++;  }
 
void setup() {
   lcd.init();
   lcd.backlight();
   delay(1000);
   lcd.setCursor(0,0); 
   lcd.print("fadim");
   delay(1000);
   lcd.setCursor(2,1);
   lcd.print("fourche");
   delay(2000);
   lcd.clear();
   // put your setup code here, to run once:
   // lcd.begin();
   pinMode(Led_Builtin, OUTPUT);
   pinMode(Green_Led,   OUTPUT);
   pinMode(Red_Led,     OUTPUT);
   pinMode(relais,      OUTPUT);
   digitalWrite(Led_Builtin, LOW);
   To = millis();
   attachInterrupt(digitalPinToInterrupt(Sensor), ISR_pulse, RISING);
}
 
void loop() {
   // lcd.clear();
   unsigned long T = millis();
   if(T - To >= 2000) {
      int c = cnt;  // normalement il faudrait rendre cette opération atomique
      cnt   = 0;
      To    = T;
      lcd.setCursor(0, 0);
      lcd.print("Vitesse_moteur :");
      lcd.setCursor(6, 1);
      revs = c * 30;
      lcd.print(revs);
      lcd.println(" RPM");
      digitalWrite(Green_Led, revs > speedLow);
      int isSpeedy = (revs > speedHigh);
      digitalWrite(Red_Led, isSpeedy);
      digitalWrite(relais, isSpeedy);
   }
}

Non testé mais cela devrait marcher. Pour mettre 3 moteurs c'est plus difficile car il n'y a que 2 interruptions hard sur un Arduino Uno. Mais même à 6000 RPM cela ne fait que 100 incréments par s soit un incrément toutes les 10 ms ce qui est à la portée d'un programme Arduino qui scrute (il suffit que la boucle passe au moins toutes les 5 ms).

Salutations

[Fadiga Mohamed fode]

Oui sa fonctionne bien et je suis très heurreux

Pour mettre 3 moteurs c'est plus difficile car il n'y a que 2 interruptions hard sur un Arduino Uno.

Alors que moi je possède un arduino méga, est il possible ? Je veux vraiment utilisé un seul arduino au lieu de 3.
merci!!!

[Fadiga Mohamed fode]

Je n'ai pas beaucoup utilisé le LCD 1602, j'ai un écran série et si c'était moi, j'utiliserais un seul écran pour afficher les valeurs de chacun des 3 capteurs.

cela est possible aussi, mais dans mon cas, il faut 3 LCD, un pour chaque moteur. J'utilise un pupitre de commande divisé en 3 parties. Chaque partie représente la commande un moteur et ses leds.

[jpbbricole]

Bonjour Fadiga Mohamed fode

... il faut 3 LCD, un pour chaque moteur. ...

Attention, pour mettre 3 LCD i2C 1602, il faut les choisir avec l'interface i2C qui a les ponts A0, A1 et A2, afin de pouvoir en changer les adresses.

Cordialement
jpbbricole

[Jay M]

Ça complexifie d’avoir 3 afficheurs. Pourquoi pas un écran plus grand ?

[Guesset]

Bonjour,

Si les trois moteurs sont indépendants et que la nécessité d'avoir 3 affichages à proximité se confirme, la contrainte devient plutôt l'Arduino Mega central (même s'il a largement assez d'interruptions hard). La solution de créer 3 modules compte-tours avec des Arduino nano ou micro (voire des Atiny) est à envisager (si alimentation locale aisée).

Salutations

[Fadiga Mohamed fode]

Bonjour Fadiga Mohamed fode

Attention, pour mettre 3 LCD i2C 1602, il faut les choisir avec l'interface i2C qui a les ponts A0, A1 et A2, afin de pouvoir en changer les adresses.

Si cela est possible je tiendrai compte de l'interface I2C.

Ça complexifie d’avoir 3 afficheurs. Pourquoi pas un écran plus grand ?

S'il y'a plus de solution pour les 3 LCD I2C, alors je prend votre proposition. Sur les sites de vente d'équipements électroniques a proximiter, je peut trouver que ces 3 variante de LCD, est il possible d'afficher la vitesse de ces 3 moteurs sur ces LCD?
https://centronik.ci/boutique/lcd-graphique-12864/
https://centronik.ci/boutique/lcd-2004-ecran/
https://centronik.ci/boutique/afficheur-lcd-1602/

[Jay M]

Concrètement à quoi doit ressembler l’affichage?

Sur un 2 lignes 16 caractères vous pourriez faire cela

Code :

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

1
2
3
4
5
 
++++++++++++++++++
|M1:vvvv  M2:vvvv|
|M3:vvvv  (tpm)  |
++++++++++++++++++

Vous n’êtes pas obligé d’écrire Mx: si besoin de plus de caractères pour les tpm


Sur un 4 lignes 20 caractères vous pourriez faire cela

Code :

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

1
2
3
4
5
6
7
 
++++++++++++++++++++++
|      VITESSES      |
|M1: vvvvvvvvvvvv tpm|
|M2: vvvvvvvvvvvv tpm|
|M3: vvvvvvvvvvvv tpm|
++++++++++++++++++++++

Sur un écran graphique vous avez encore plus de liberté quant au placement du texte.

[Fadiga Mohamed fode]

Ok Jay M j'essaie de faire un programme pour les 3 LCD, J'y tiens vraiment à cela d'abord. Merci

[Jay M]

Pas de souci - il faudra trouver des écrans dont on peut régler l’adresse sinon utiliser un multiplexeur I2C

[Fadiga Mohamed fode]

Pas de souci - il faudra trouver des écrans dont on peut régler l’adresse sinon utiliser un multiplexeur I2C

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
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
 
LiquidCrystal_I2C lcd1(0x27, 16, 2);
LiquidCrystal_I2C lcd2(0x26, 16, 2);
LiquidCrystal_I2C lcd3(0x25, 16, 2);
const byte led_Builtin;
const byte sensor1 = 2;
const byte sensor2 = 3;
const byte sensor3 = 18;
 
const byte Green_led1  = 5;
const byte Red_led1 = 6;
const byte relais1 = 7;
 
const byte Green_led2  = 8;
const byte Red_led2 = 9;
const byte relais2 = 10;
 
const byte Green_led3  =11;
const byte Red_led3 = 12;
const byte relais3 = 13;
 
volatile int cnt1 = 0;
volatile int cnt2 = 0;
volatile int cnt3 = 0;
volatile int revs1 = 0;
volatile int revs2 = 0;
volatile int revs3 = 0;
 
const int SpeedLow1 = 500;
const int SpeedHigh1 = 2000;
unsigned long To1;
const int SpeedLow2 = 500;
const int SpeedHigh2 = 2000;
unsigned long To2;
const int SpeedLow3 = 500;
const int SpeedHigh3 = 2000;
unsigned long To3;
 
void ISR1_pulse(){
   cnt1++; 
}
 
void ISR2_pulse(){
   cnt2++; 
}
 
void ISR3_pulse(){
   cnt3++; 
}
 
void setup() {
  // put your setup code here, to run once:
  lcd1.init();
  lcd2.init(); 
  lcd3.init();
  lcd1.backlight();
  lcd2.backlight();
  lcd3.backlight();
  delay(1000);
  lcd1.setCursor(0,0);
  lcd1.print("fadim1");
  delay(1000);
  lcd1.setCursor(2,1);
  lcd1.print("fourche1");
  delay(2000);
  lcd1.clear();
 
  lcd2.setCursor(0,0);
  lcd2.print("fadim2");
  delay(1000);
  lcd2.setCursor(2,1);
  lcd2.print("fourche2");
  delay(2000);
  lcd2.clear();
 
  lcd3.setCursor(0,0);
  lcd3.print("fadim3");
  delay(1000);
  lcd3.setCursor(2,1);
  lcd3.print("fourche3");
  delay(2000);
  lcd3.clear();
 
  pinMode(led_Builtin,OUTPUT);
  //pinMode(sensor,INPUT);
  pinMode(Green_led1,OUTPUT);
  pinMode(Red_led1,OUTPUT);
  pinMode(relais1,OUTPUT);
 
  pinMode(Green_led2,OUTPUT);
  pinMode(Red_led2,OUTPUT);
  pinMode(relais2,OUTPUT);
 
  pinMode(Green_led3,OUTPUT);
  pinMode(Red_led3,OUTPUT);
  pinMode(relais3,OUTPUT);
 
  digitalWrite(led_Builtin,LOW);
  attachInterrupt(digitalPinToInterrupt(sensor1),ISR1_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor2),ISR2_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor3),ISR3_pulse, RISING);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  unsigned long T1 = millis();
  unsigned long T2 = millis();
  unsigned long T3 = millis();
  if ( T1 - To1 >= 2000) {
    int c1 = cnt1; 
    cnt1 = 0;
    To1 = T1; 
 
    lcd1.setCursor(0,0);
    lcd1.print("Vitesse_moteur1:");
    lcd1.setCursor(6,1);
    revs1 = c1 * 30;
    lcd1.print(revs1);
    lcd1.println("RPM");
 
   digitalWrite(Green_led1,revs1 > SpeedLow1);
    int isSpeedy1 = (revs1 > SpeedHigh1);
    digitalWrite(Red_led1, isSpeedy1);
    digitalWrite(relais1, isSpeedy1);    
 
  }
 
  if ( T2 - To2 >= 2000) {
    int c2 = cnt2; 
    cnt2 = 0;
    To2 = T2;
 
    lcd2.setCursor(0,0);
    lcd2.print("Vitesse_moteur2:");
    lcd2.setCursor(6,1);
    revs2 = c2 * 30;
    lcd2.print(revs2);
    lcd2.println("RPM");
 
    digitalWrite(Green_led2,revs2 > SpeedLow2);
    int isSpeedy2 = (revs2 > SpeedHigh2);
    digitalWrite(Red_led2, isSpeedy2);
    digitalWrite(relais2, isSpeedy2);
  }
 
  if ( T3 - To3 >= 2000) {
    int c3 = cnt3; 
    cnt3 = 0;
    To3 = T3;
 
    lcd3.setCursor(0,0);
    lcd3.print("Vitesse_moteur3:");
    lcd3.setCursor(6,1);
    revs3 = c3 * 30;
    lcd3.print(revs3);
    lcd3.println("RPM");
 
    digitalWrite(Green_led3,revs3 > SpeedLow3);
    int isSpeedy3 = (revs3 > SpeedHigh3);
    digitalWrite(Red_led3, isSpeedy3);
    digitalWrite(relais3, isSpeedy3);
  }
}

[Fadiga Mohamed fode]

Pas de souci - il faudra trouver des écrans dont on peut régler l’adresse sinon utiliser un multiplexeur I2C

bonjour j'ai reçu aujourd'hui la commande pour mes 2 autres LCD I2C et j'ai bidouillé ce programme. Pour un premier temps, j'ai reçu à afficher la vitesse de chaque moteur sur son écran LCD. Apparemment et après quelques test sa l'air de fonctionner bien.
Je trouve que mon programme est assé long mais ...

Alors si vous trouvez que le programme est mal structuré ou qu'il y'a quelques chose à rajouter pour que programme soit sans faute n'hésiter pas.

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
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
 
LiquidCrystal_I2C lcd1(0x27, 16, 2);
LiquidCrystal_I2C lcd2(0x26, 16, 2);
LiquidCrystal_I2C lcd3(0x25, 16, 2);
const byte led_Builtin;
const byte sensor1 = 2;
const byte sensor2 = 3;
const byte sensor3 = 18;
 
const byte Green_led1  = 5;
const byte Red_led1 = 6;
const byte relais1 = 7;
 
const byte Green_led2  = 8;
const byte Red_led2 = 9;
const byte relais2 = 10;
 
const byte Green_led3  =11;
const byte Red_led3 = 12;
const byte relais3 = 13;
 
volatile int cnt1 = 0;
volatile int cnt2 = 0;
volatile int cnt3 = 0;
volatile int revs1 = 0;
volatile int revs2 = 0;
volatile int revs3 = 0;
 
const int SpeedLow1 = 500;
const int SpeedHigh1 = 2000;
unsigned long To1;
const int SpeedLow2 = 500;
const int SpeedHigh2 = 2000;
unsigned long To2;
const int SpeedLow3 = 500;
const int SpeedHigh3 = 2000;
unsigned long To3;
 
void ISR1_pulse(){
   cnt1++; 
}
 
void ISR2_pulse(){
   cnt2++; 
}
 
void ISR3_pulse(){
   cnt3++; 
}
 
void setup() {
  // put your setup code here, to run once:
  lcd1.init();
  lcd2.init(); 
  lcd3.init();
  lcd1.backlight();
  lcd2.backlight();
  lcd3.backlight();
  delay(1000);
  lcd1.setCursor(0,0);
  lcd1.print("fadim1");
  delay(1000);
  lcd1.setCursor(2,1);
  lcd1.print("fourche1");
  delay(2000);
  lcd1.clear();
 
  lcd2.setCursor(0,0);
  lcd2.print("fadim2");
  delay(1000);
  lcd2.setCursor(2,1);
  lcd2.print("fourche2");
  delay(2000);
  lcd2.clear();
 
  lcd3.setCursor(0,0);
  lcd3.print("fadim3");
  delay(1000);
  lcd3.setCursor(2,1);
  lcd3.print("fourche3");
  delay(2000);
  lcd3.clear();
 
  pinMode(led_Builtin,OUTPUT);
  //pinMode(sensor,INPUT);
  pinMode(Green_led1,OUTPUT);
  pinMode(Red_led1,OUTPUT);
  pinMode(relais1,OUTPUT);
 
  pinMode(Green_led2,OUTPUT);
  pinMode(Red_led2,OUTPUT);
  pinMode(relais2,OUTPUT);
 
  pinMode(Green_led3,OUTPUT);
  pinMode(Red_led3,OUTPUT);
  pinMode(relais3,OUTPUT);
 
  digitalWrite(led_Builtin,LOW);
  attachInterrupt(digitalPinToInterrupt(sensor1),ISR1_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor2),ISR2_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor3),ISR3_pulse, RISING);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  unsigned long T1 = millis();
  unsigned long T2 = millis();
  unsigned long T3 = millis();
  if ( T1 - To1 >= 2000) {
    int c1 = cnt1; 
    cnt1 = 0;
    To1 = T1; 
 
    lcd1.setCursor(0,0);
    lcd1.print("Vitesse_moteur1:");
    lcd1.setCursor(6,1);
    revs1 = c1 * 30;
    lcd1.print(revs1);
    lcd1.println("RPM");
 
   digitalWrite(Green_led1,revs1 > SpeedLow1);
    int isSpeedy1 = (revs1 > SpeedHigh1);
    digitalWrite(Red_led1, isSpeedy1);
    digitalWrite(relais1, isSpeedy1);    
 
  }
 
  if ( T2 - To2 >= 2000) {
    int c2 = cnt2; 
    cnt2 = 0;
    To2 = T2;
 
    lcd2.setCursor(0,0);
    lcd2.print("Vitesse_moteur2:");
    lcd2.setCursor(6,1);
    revs2 = c2 * 30;
    lcd2.print(revs2);
    lcd2.println("RPM");
 
    digitalWrite(Green_led2,revs2 > SpeedLow2);
    int isSpeedy2 = (revs2 > SpeedHigh2);
    digitalWrite(Red_led2, isSpeedy2);
    digitalWrite(relais2, isSpeedy2);
  }
 
  if ( T3 - To3 >= 2000) {
    int c3 = cnt3; 
    cnt3 = 0;
    To3 = T3;
 
    lcd3.setCursor(0,0);
    lcd3.print("Vitesse_moteur3:");
    lcd3.setCursor(6,1);
    revs3 = c3 * 30;
    lcd3.print(revs3);
    lcd3.println("RPM");
 
    digitalWrite(Green_led3,revs3 > SpeedLow3);
    int isSpeedy3 = (revs3 > SpeedHigh3);
    digitalWrite(Red_led3, isSpeedy3);
    digitalWrite(relais3, isSpeedy3);
  }
}

Bonjour Fadiga Mohamed fode

Attention, pour mettre 3 LCD i2C 1602, il faut les choisir avec l'interface i2C qui a les ponts A0, A1 et A2[/URL], afin de pouvoir en changer les adresses.

comme tu la si bi bien dit, pour trouver l'adresse des 3 LCD, le 1er LCD j'ai pas le pont sur le A0, A1 et A2 de son I2C, donc il a l'adresse ( 0,27).
le 2 em LCD j'ai fais le pont sur le A0 de son IIC, donc il a l'adresse (0,26).
le 3 èm LCD j'ai fais le pont sur le A1 de son IIC, donc il a l'adresse (0,25).

[Guesset]

Bonjour,

Bravo pour ce succès.

Ce serait bien de déplacer T2 et T3 juste avant leur comparaison avec To2 et To3.

Les seuils de vitesse hauts et bas sont les mêmes. Pourquoi les multiplier ?

En créant une structure qui conserve les éléments caractérisant chaque moteur (pin senseur, Tx, Tox, relais etc.) puis en créant un tableau de trois fois cette structure, le programme peut être simplifié et facilement extensible à plus de moteurs.

Salutations

[Fadiga Mohamed fode]

Bonjour,

Bravo pour ce succès.

je vous dit un grand merci.

Ce serait bien de déplacer T2 et T3 juste avant leur comparaison avec To2 et To3.

cela est fait!!!

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
 
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
 
LiquidCrystal_I2C lcd1(0x27, 16, 2);
LiquidCrystal_I2C lcd2(0x26, 16, 2);
LiquidCrystal_I2C lcd3(0x25, 16, 2);
const byte led_Builtin;
const byte sensor1 = 2;
const byte sensor2 = 3;
const byte sensor3 = 18;
 
const byte Green_led1  = 5;
const byte Red_led1 = 6;
const byte relais1 = 7;
 
const byte Green_led2  = 8;
const byte Red_led2 = 9;
const byte relais2 = 10;
 
const byte Green_led3  =11;
const byte Red_led3 = 12;
const byte relais3 = 13;
 
volatile int cnt1 = 0;
volatile int cnt2 = 0;
volatile int cnt3 = 0;
volatile int revs1 = 0;
volatile int revs2 = 0;
volatile int revs3 = 0;
 
const int SpeedLow = 500;
const int SpeedHigh = 2000;
unsigned long To1;
unsigned long To2;
unsigned long To3;
 
void ISR1_pulse(){
   cnt1++; 
}
 
void ISR2_pulse(){
   cnt2++; 
}
 
void ISR3_pulse(){
   cnt3++; 
}
 
void setup() {
  // put your setup code here, to run once:
  lcd1.init();
  lcd2.init(); 
  lcd3.init();
  lcd1.backlight();
  lcd2.backlight();
  lcd3.backlight();
  delay(1000);
  lcd1.setCursor(0,0);
  lcd1.print("fadim1");
  delay(1000);
  lcd1.setCursor(2,1);
  lcd1.print("fourche1");
  delay(2000);
  lcd1.clear();
 
  lcd2.setCursor(0,0);
  lcd2.print("fadim2");
  delay(1000);
  lcd2.setCursor(2,1);
  lcd2.print("fourche2");
  delay(2000);
  lcd2.clear();
 
  lcd3.setCursor(0,0);
  lcd3.print("fadim3");
  delay(1000);
  lcd3.setCursor(2,1);
  lcd3.print("fourche3");
  delay(2000);
  lcd3.clear();
 
  pinMode(led_Builtin,OUTPUT);
  //pinMode(sensor,INPUT);
  pinMode(Green_led1,OUTPUT);
  pinMode(Red_led1,OUTPUT);
  pinMode(relais1,OUTPUT);
 
  pinMode(Green_led2,OUTPUT);
  pinMode(Red_led2,OUTPUT);
  pinMode(relais2,OUTPUT);
 
  pinMode(Green_led3,OUTPUT);
  pinMode(Red_led3,OUTPUT);
  pinMode(relais3,OUTPUT);
 
  digitalWrite(led_Builtin,LOW);
  attachInterrupt(digitalPinToInterrupt(sensor1),ISR1_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor2),ISR2_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor3),ISR3_pulse, RISING);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  unsigned long T1 = millis();
  if ( T1 - To1 >= 2000) {
    int c1 = cnt1; 
    cnt1 = 0;
    To1 = T1; 
 
    lcd1.setCursor(0,0);
    lcd1.print("Vitesse_moteur1:");
    lcd1.setCursor(6,1);
    revs1 = c1 * 30;
    lcd1.print(revs1);
    lcd1.println("RPM");
 
   digitalWrite(Green_led1,revs1 > SpeedLow);
    int isSpeedy1 = (revs1 > SpeedHigh);
    digitalWrite(Red_led1, isSpeedy1);
    digitalWrite(relais1, isSpeedy1);    
 
  }
  unsigned long T2 = millis();
  if ( T2 - To2 >= 2000) {
    int c2 = cnt2; 
    cnt2 = 0;
    To2 = T2;
 
    lcd2.setCursor(0,0);
    lcd2.print("Vitesse_moteur2:");
    lcd2.setCursor(6,1);
    revs2 = c2 * 30;
    lcd2.print(revs2);
    lcd2.println("RPM");
 
    digitalWrite(Green_led2,revs2 > SpeedLow);
    int isSpeedy2 = (revs2 > SpeedHigh);
    digitalWrite(Red_led2, isSpeedy2);
    digitalWrite(relais2, isSpeedy2);
  }
 
  unsigned long T3 = millis();
  if ( T3 - To3 >= 2000) {
    int c3 = cnt3; 
    cnt3 = 0;
    To3 = T3;
 
    lcd3.setCursor(0,0);
    lcd3.print("Vitesse_moteur3:");
    lcd3.setCursor(6,1);
    revs3 = c3 * 30;
    lcd3.print(revs3);
    lcd3.println("RPM");
 
    digitalWrite(Green_led3,revs3 > SpeedLow);
    int isSpeedy3 = (revs3 > SpeedHigh);
    digitalWrite(Red_led3, isSpeedy3);
    digitalWrite(relais3, isSpeedy3);
  }
}

Les seuils de vitesse hauts et bas sont les mêmes. Pourquoi les multiplier ?

je crois que je l'ai changé aussi

En créant une structure qui conserve les éléments caractérisant chaque moteur (pin senseur, Tx, Tox, relais etc.) puis en créant un tableau de trois fois cette structure, le programme peut être simplifié et facilement extensible à plus de moteurs.

aah là, sa chauffe ma tête et je de demande le renfort, mais quand même j'ai fais ceci

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
 
 #include <LiquidCrystal_I2C.h>
#include <Wire.h> 
#define relaisrNombre 3
#define ToNombre 3
LiquidCrystal_I2C lcd1(0x27, 16, 2);
LiquidCrystal_I2C lcd2(0x26, 16, 2);
LiquidCrystal_I2C lcd3(0x25, 16, 2);
 
#define sensorNombre ledNombre *1
//mise en tableau des pin des sensors
const byte sensorPin [] = { 2, 3, 18};
const byte sensorEtatDetect = LOW; // Etat lu d'un sensor detecté
const byte led_Builtin;
 
#define ledNombre 9
const byte ledPin [] = { 4, 5, 6, 7, 8, 9, 10, 11, 12};
led led[ledNombre]; //création des leds en tableau
int ledDebut = [ledNombre];
const byte relaisPin [] = { 14, 15, 16};
 
unsigned long To [] = { To1, To2, To3};
 
volatile int cnt1 = 0;
volatile int cnt2 = 0;
volatile int cnt3 = 0;
volatile int revs1 = 0;
volatile int revs2 = 0;
volatile int revs3 = 0;
const int SpeedLow = 500;
const int SpeedMidle = 1999;
const int SpeedHigh = 2000;
 
void ISR1_pulse() {
  cnt1++;
}
 
void ISR2_pulse() {
  cnt2++;
}
 
void ISR3_pulse() {
  cnt3++;
}
 
void setup() {
  // put your setup code here, to run once:
  lcd.println("\Initialisation des Leds");
  lcd1.init();
  lcd2.init();
  lcd3.init();
  lcd1.backlight();
  lcd2.backlight();
  lcd3.backlight();
  delay(1000);
  lcd1.setCursor(0, 0);
  lcd1.print("fadim1");
  delay(1000);
  lcd1.setCursor(2, 1);
  lcd1.print("fourche1");
  delay(2000);
  lcd1.clear();
 
  lcd2.setCursor(0, 0);
  lcd2.print("fadim2");
  delay(1000);
  lcd2.setCursor(2, 1);
  lcd2.print("fourche2");
  delay(2000);
  lcd2.clear();
 
  lcd3.setCursor(0, 0);
  lcd3.print("fadim3");
  delay(1000);
  lcd3.setCursor(2, 1);
  lcd3.print("fourche3");
  delay(2000);
  lcd3.clear();
  for ( int s = 0; s < ledNombre; s ++)
  {
    led[s].attach(ledPin[s]);
  }
 
 
//for(int b = 0; b < sensorNombre; b ++){
  pinMode(led_Builtin, OUTPUT);
  //pinMode(sensor,INPUT);
  pinMode(Green_led1, OUTPUT);
  pinMode(Red_led1, OUTPUT);
  pinMode(relais1, OUTPUT);
 
  pinMode(Green_led2, OUTPUT);
  pinMode(Red_led2, OUTPUT);
  pinMode(relais2, OUTPUT);
 
  pinMode(Green_led3, OUTPUT);
  pinMode(Red_led3, OUTPUT);
  pinMode(relais3, OUTPUT);
 
  digitalWrite(led_Builtin, LOW);
  attachInterrupt(digitalPinToInterrupt(1), ISR1_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(2), ISR2_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(3), ISR3_pulse, RISING);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  unsigned long T1 = millis();
  //for (int s = 0; s < ledNombre; s ++){
  if ( T1 - To1 >= 2000) {
    int c1 = cnt1;
    cnt1 = 0;
    To1 = T1;
 
    lcd1.setCursor(0, 0);
    lcd1.print("Vitesse_moteur1:");
    lcd1.setCursor(6, 1);
    revs1 = c1 * 30;
    lcd1.print(revs1);
    lcd1.println("RPM");
 
    digitalWrite(Green_led1, revs1 < SpeedLow1);
    digitalWrite(
    int isSpeedy1 = (revs1 > SpeedHigh1);
    digitalWrite(Red_led1, isSpeedy1);
    digitalWrite(relais1, isSpeedy1);
  }
}
unsigned long T2 = millis();
if ( T2 - To2 >= 2000) {
  int c2 = cnt2;
  cnt2 = 0;
  To2 = T2;
 
  lcd2.setCursor(0, 0);
  lcd2.print("Vitesse_moteur2:");
  lcd2.setCursor(6, 1);
  revs2 = c2 * 30;
  lcd2.print(revs2);
  lcd2.println("RPM");
 
  digitalWrite(Green_led2, revs2 > SpeedLow2);
  int isSpeedy2 = (revs2 > SpeedHigh2);
  digitalWrite(Red_led2, isSpeedy2);
  digitalWrite(relais2, isSpeedy2);
}
 
unsigned long T3 = millis();
if ( T3 - To3 >= 2000) {
  int c3 = cnt3;
  cnt3 = 0;
  To3 = T3;
 
  lcd3.setCursor(0, 0);
  lcd3.print("Vitesse_moteur3:");
  lcd3.setCursor(6, 1);
  revs3 = c3 * 30;
  lcd3.print(revs3);
  lcd3.println("RPM");
 
  digitalWrite(Green_led3, revs3 > SpeedLow3);
  int isSpeedy3 = (revs3 > SpeedHigh3);
  digitalWrite(Red_led3, isSpeedy3);
  digitalWrite(relais3, isSpeedy3);
}
}

[Guesset]

Bonjour,

La mise en tableau est une première approche mais elle est un peu lourde et le code ne l'utilise pas vraiment.

En réfléchissant au problème, il est évident que c'est 3 fois le même. Donc si on déclare une structure qui recueille les caractéristiques d'un moteur et en créant un tableau de 3 fois cette structure le code s'en trouve allégé.
Exemple à compléter :

Code C++ :

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
 
...
#define MotorsNb 3
struct Motor {
   LiquidCrystal_I2C lcd;
   const byte    Sensor;
   const byte    GLed;
   const byte    RLed;
   const byte    Relais;
   unsigned long To;
   }
Motor Motrs[MotorsNb] = {
 // lcd, Sensor, GLed, RLed, Relais, To
   {lcd1,     2,    5,    6,      7,  0},
   {lcd2,     3,    8,    9,     10,  0},
   {lcd3,    18,   11,   12,     13,  0}
   };
volatile int cnt[MotorsNb];
volatile int revs[MotorsNb]; // Pourrait être dans la structure mais certains compilateurs étendent la volatilité à toute la structure (à vérifier)
int iM = 0; // indice du moteur courant 0..2 incrémenté modulo 3 dans loop()
...

Chaque itération de loop() traite un moteur différent. Même les affichages sont indexés, par exemple :

Code C++ :

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

1
2
   cd3.setCursor(0, 0);
   lcd3.print("Vitesse_moteur3:");

devient :

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
 
   lcd3.print("Vitesse_moteur :"); // dans setup
   ...
   Motors[iM].lcd.setCursor(14, 0); // dans loop
   Motors[iM].lcd.print(iM);
   Motors[iM].lcd.print(":");
   ...
   // fin de loop
   iM -= iM ? 1: -2; // 0 -> 2 -> 1 -> 0 
   ...

L'écriture est un peu plus lourde mais elle est divisée par 3.

D'un autre coté si le code actuel fonctionne, le garder et n'en créer une variante que pour la tester se justifie pleinement.

Salutations

[Fadiga Mohamed fode]

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
 
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
 
LiquidCrystal_I2C lcd1(0x27, 16, 2);
LiquidCrystal_I2C lcd2(0x26, 16, 2);
LiquidCrystal_I2C lcd3(0x25, 16, 2);
const byte led_Builtin;
const byte sensor1 = 2;
const byte sensor2 = 3;
const byte sensor3 = 18;
 
const byte Red_led1 = 5;
const byte Red_led2 = 6;
const byte Red_led3 = 7;
 
const byte Blue_led1 = 8;
const byte Blue_led2 = 9;
const byte Blue_led3 = 10;
 
const byte Green_led1  = 11;
const byte Green_led2  = 12;
const byte Green_led3  =13;
 
volatile int cnt1 = 0;
volatile int cnt2 = 0;
volatile int cnt3 = 0;
volatile int revs1 = 0;
volatile int revs2 = 0;
volatile int revs3 = 0;
 
const int Stop =0;
const int SpeedLow = 500;
const int SpeedHigh = 2000;
unsigned long To1;
unsigned long To2;
unsigned long To3;
 
void ISR1_pulse(){
   cnt1++; 
}
 
void ISR2_pulse(){
   cnt2++; 
}
 
void ISR3_pulse(){
   cnt3++; 
}
 
void setup() {
  // put your setup code here, to run once:
  lcd1.init();
  lcd2.init(); 
  lcd3.init();
  lcd1.backlight();
  lcd2.backlight();
  lcd3.backlight();
  delay(1000);
  lcd1.setCursor(0,0);
  lcd1.print("KOSSOU_G1");
  delay(1000);
  lcd1.setCursor(2,1);
  lcd1.print("ALTERNATEUR_1");
  delay(2000);
  lcd1.clear();
 
  lcd2.setCursor(0,2);
  lcd2.print("KOSSOU_G2");
  delay(1000);
  lcd2.setCursor(2,1);
  lcd2.print("ALTERNATEUR_2");
  delay(2000);
  lcd2.clear();
 
  lcd3.setCursor(0,0);
  lcd3.print("KOSSOU_G3");
  delay(1000);
  lcd3.setCursor(2,1);
  lcd3.print("ALTERNATEUR_3");
  delay(2000);
  lcd3.clear();
 
  pinMode(led_Builtin,OUTPUT);
  //pinMode(sensor,INPUT);
  pinMode(Red_led1,OUTPUT);
  pinMode(Red_led2,OUTPUT);
  pinMode(Red_led3,OUTPUT);
 
  pinMode(Blue_led1,OUTPUT);
  pinMode(Blue_led2,OUTPUT);
  pinMode(Blue_led3,OUTPUT);
 
  pinMode(Green_led1,OUTPUT);
  pinMode(Green_led2,OUTPUT);
  pinMode(Green_led3,OUTPUT);
 
  digitalWrite(led_Builtin,LOW);
  attachInterrupt(digitalPinToInterrupt(sensor1),ISR1_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor2),ISR2_pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(sensor3),ISR3_pulse, RISING);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  unsigned long T1 = millis();
  if ( T1 - To1 >= 2000) {
    int c1 = cnt1; 
    cnt1 = 0;
    To1 = T1; 
 
    lcd1.setCursor(0,0);
    lcd1.print("Vitesse_Turbine1:");
    lcd1.setCursor(6,1);
    revs1 = c1 * 30;
    lcd1.print(revs1);
    lcd1.println("RPM");
 
 
    digitalWrite(Red_led1,revs1 == Stop);
    digitalWrite(Blue_led1,revs1 > Stop < SpeedHigh);
    int isSpeedy1 = (revs1 > SpeedHigh);
    digitalWrite(Green_led1, isSpeedy1);   
 
  }
  unsigned long T2 = millis();
  if ( T2 - To2 >= 2000) {
    int c2 = cnt2; 
    cnt2 = 0;
    To2 = T2;
 
    lcd2.setCursor(0,0);
    lcd2.print("Vitesse_Turbine2:");
    lcd2.setCursor(6,1);
    revs2 = c2 * 30;
    lcd2.print(revs2);
    lcd2.println("RPM");
 
    digitalWrite(Blue_led2,revs2 == Stop);
    digitalWrite(Green_led2,revs2 > SpeedLow);
    int isSpeedy2 = (revs2 > SpeedHigh);
    digitalWrite(Red_led2, isSpeedy2);
  }
 
  unsigned long T3 = millis();
  if ( T3 - To3 >= 2000) {
    int c3 = cnt3; 
    cnt3 = 0;
    To3 = T3;
 
    lcd3.setCursor(0,0);
    lcd3.print("Vitesse_Turbine3:");
    lcd3.setCursor(6,1);
    revs3 = c3 * 30;
    lcd3.print(revs3);
    lcd3.println("RPM");
 
    digitalWrite(Blue_led3,revs3 == Stop);
    digitalWrite(Red_led3,revs3 > SpeedLow);
    int isSpeedy3 = (revs3 > SpeedHigh);
    digitalWrite(Green_led3, isSpeedy3);
  }
}

+1 avec @Guesset sur le tableau de structure (on s'approche d'une conception objet)

Je vais testé de suite. Je voulais utilisé une LED-RGB à la place des de Geen_les, Red_les et supprimé le Relais.
donc je veux que la sur la LED_RGB, si vitesse = 0 la couleur Rouge s'allume sinon elle s'éteint. et si la vitesse est > 0 et < 2000; la couleur Bleu s'allume, sinon elle s'éteint; et la Green s'allume quand vitesse est superieur à 2000.

Code :

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

1
2
3
4
5
 
digitalWrite(Red_led1,revs1 == Stop);
    digitalWrite(Blue_led1,revs1 > Stop < SpeedHigh);
    int isSpeedy1 = (revs1 > SpeedHigh);
    digitalWrite(Green_led1, isSpeedy1);

mes si je fais cela la couleur Rouge s'allume avec le Bleu au départ. Je veux que Rouge s'allume et s'éteint avant que le Bleu ne s'allume et le vers aussi

[Jay M]

+1 avec @Guesset sur le tableau de structure (on s'approche d'une conception objet)

On peut utiliser une Range-based for loop pour simplifier les boucles et se passer de l'indice.

on peut aussi simplifier car finalement tous les écrans se mettent à jour en même temps au bout de 2 secondes donc pas vraiment besoin de mémoriser le temps précédent par moteur.

par exemple ça pourrait donner un truc comme cela (totalement non testé)

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
#include <LiquidCrystal_I2C.h>
 
const byte nombreAppareils = 3;
const long vitesseFaible  =  500;
const long vitesseHaute   = 2000;
unsigned long tempsPrecedent;
 
struct Appareil {
  const byte    id;
  const char*   message;
  LiquidCrystal_I2C lcd;
  const byte    pinCapteur;
  const byte    pinLedVerte;
  const byte    pinLedRouge;
  const byte    pinRelai;
  void (*ISR)();
};
 
volatile long compteurs[nombreAppareils];
void impulsion0() {compteurs[0]++;}
void impulsion1() {compteurs[1]++;}
void impulsion2() {compteurs[2]++;}
 
Appareil lesAppareils[nombreAppareils] = {
  // id, lcd, Sensor, GLed, RLed, Relais, ISR
  {0, "V fourche 1", {0x25, 16, 2},     2,    5,    6,      7,  impulsion0},
  {1, "V fourche 2", {0x26, 16, 2},     3,    8,    9,     10,  impulsion1},
  {2, "V fourche 3", {0x27, 16, 2},    18,   11,   12,     13,  impulsion2},
};
 
void setup () {
  for (auto && unAppareil : lesAppareils) {
    pinMode(unAppareil.pinCapteur,  INPUT );
    pinMode(unAppareil.pinLedVerte, OUTPUT);
    pinMode(unAppareil.pinLedRouge, OUTPUT);
    pinMode(unAppareil.pinRelai,    OUTPUT);
    unAppareil.lcd.init();
    unAppareil.lcd.backlight();
    unAppareil.lcd.setCursor(0, 0);
    unAppareil.lcd.print(unAppareil.message);
    attachInterrupt(digitalPinToInterrupt(unAppareil.pinCapteur), unAppareil.ISR, RISING);
  }
}
 
void loop () {
  unsigned long maintenant = millis();
  if (maintenant - tempsPrecedent >= 2000ul) { // effectuer la mise à jour de l'affichage
    tempsPrecedent = maintenant;
    for (auto && unAppareil : lesAppareils) {
      // attention on ne peut pas toucher à une variable volatile de plusieurs octets de manière atomique
      // section critique
      noInterrupts();
      long cntCopie = compteurs[unAppareil.id];
      compteurs[unAppareil.id] = 0;
      interrupts();
      long rpm = cntCopie * 30;
      unAppareil.lcd.setCursor(6, 1);
      unAppareil.lcd.print(rpm); unAppareil.lcd.print(F(" RPM    "));
      digitalWrite(unAppareil.pinLedVerte, (rpm > vitesseFaible) ? HIGH : LOW);
      digitalWrite(unAppareil.pinLedRouge, (rpm > vitesseHaute)  ? HIGH : LOW);
      digitalWrite(unAppareil.pinRelai,    (rpm > vitesseHaute)  ? HIGH : LOW);
    }
  }
}

notez les espaces dans le texte de unAppareil.lcd.print(F(" RPM ")); qui sont là pour effacer des traces quand la vitesse diminue