IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Affichage de la vitesse de rotation d'un moteur sur LCD I2C 1602


Sujet :

Arduino

  1. #1
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut Affichage de la vitesse de rotation d'un moteur sur LCD I2C 1602
    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 !!!

  2. #2
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    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 !!!

  3. #3
    Membre du Club
    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2021
    Messages
    45
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : Australie

    Informations professionnelles :
    Activité : Architecte technique

    Informations forums :
    Inscription : juin 2021
    Messages : 45
    Points : 64
    Points
    64
    Par défaut
    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.

  4. #4
    Membre expérimenté

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    505
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 505
    Points : 1 559
    Points
    1 559
    Par défaut Interruption sans arrêt
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  5. #5
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Oui sa fonctionne bien et je suis très heurreux
    Citation Envoyé par Guesset Voir le message
    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!!!

  6. #6
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Citation Envoyé par paulli Voir le message
    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.

  7. #7
    Membre chevronné
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    883
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 883
    Points : 2 025
    Points
    2 025
    Par défaut
    Bonjour Fadiga Mohamed fode
    Citation Envoyé par Fadiga Mohamed fode Voir le message
    ... 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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  8. #8
    Membre expert

    Homme Profil pro
    mad scientist :)
    Inscrit en
    septembre 2019
    Messages
    1 706
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : septembre 2019
    Messages : 1 706
    Points : 3 316
    Points
    3 316
    Par défaut
    Ça complexifie d’avoir 3 afficheurs. Pourquoi pas un écran plus grand ?

  9. #9
    Membre expérimenté

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    505
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 505
    Points : 1 559
    Points
    1 559
    Par défaut Plus mais plus petit
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  10. #10
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Citation Envoyé par jpbbricole Voir le message
    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.

    Citation Envoyé par Jay M Voir le message
    Ç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/

  11. #11
    Membre expert

    Homme Profil pro
    mad scientist :)
    Inscrit en
    septembre 2019
    Messages
    1 706
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : septembre 2019
    Messages : 1 706
    Points : 3 316
    Points
    3 316
    Par défaut
    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.

  12. #12
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Ok Jay M j'essaie de faire un programme pour les 3 LCD, J'y tiens vraiment à cela d'abord. Merci

  13. #13
    Membre expert

    Homme Profil pro
    mad scientist :)
    Inscrit en
    septembre 2019
    Messages
    1 706
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : septembre 2019
    Messages : 1 706
    Points : 3 316
    Points
    3 316
    Par défaut
    Pas de souci - il faudra trouver des écrans dont on peut régler l’adresse sinon utiliser un multiplexeur I2C

  14. #14
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Citation Envoyé par Jay M Voir le message
    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);
      }
    }

  15. #15
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Citation Envoyé par Jay M Voir le message
    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);
      }
    }
    Citation Envoyé par jpbbricole Voir le message
    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).

  16. #16
    Membre expérimenté

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    505
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 505
    Points : 1 559
    Points
    1 559
    Par défaut Améliorations ?
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  17. #17
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    Citation Envoyé par Guesset Voir le message
    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);
    }
    }

  18. #18
    Membre expérimenté

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    505
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 505
    Points : 1 559
    Points
    1 559
    Par défaut
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  19. #19
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2019
    Messages
    71
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2019
    Messages : 71
    Points : 15
    Points
    15
    Par défaut
    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);
      }
    }
    Citation Envoyé par Jay M Voir le message
    +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

  20. #20
    Membre expert

    Homme Profil pro
    mad scientist :)
    Inscrit en
    septembre 2019
    Messages
    1 706
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : septembre 2019
    Messages : 1 706
    Points : 3 316
    Points
    3 316
    Par défaut
    +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

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Contrôle de la vitesse de rotation d'un moteur avec Arduino
    Par capteurtipe dans le forum Arduino
    Réponses: 6
    Dernier message: 09/06/2017, 12h38
  2. Réponses: 45
    Dernier message: 30/05/2017, 14h53
  3. Capteur de vitesse de rotation d'un banc d'essai
    Par TinyFactory dans le forum LabVIEW
    Réponses: 1
    Dernier message: 17/03/2017, 09h30
  4. Réponses: 1
    Dernier message: 28/06/2011, 15h51
  5. Réponses: 9
    Dernier message: 13/09/2006, 21h44

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo