Partage
  • Partager sur Facebook
  • Partager sur Twitter

commande moteur par ultrason Arduino

tinkercad

    7 mai 2020 à 15:55:13

    Bonjour, 

    Je souhaiterai réaliser un système permettant d'ouvrir la porte d'une boite.

    Avant de réaliser réellement le câblage, j'ai voulu réaliser une simulation sur le logiciel "tinkercad".

    Je souhaite que le système fonctionne comme expliqué ci-dessous : 

    Lorsque le capteur ultrasons détecte un objet (mains) à moins de 2m il actionne le moteur grâce au pont en H. Une fois la porte ouverte elle attend 10secondes avant de se refermer. 

    Aujourd'hui mon problème est que mon programme ne marche pas et je ne comprend pas pourquoi...

    Je vous met donc le lien de mon projet : https://www.tinkercad.com/things/08OH8OoqgLA-boite-composte/editel?sharecode=QxQ2lhuGXYPZjnKLH1fnYy_ifKoUEqmlF4frjASxYbM  si quelqu'un peut y jeter un coup d'oeil...

    Merci d'avance.

    -
    Edité par SimonGuillois 7 mai 2020 à 15:56:21

    • Partager sur Facebook
    • Partager sur Twitter
      7 mai 2020 à 16:12:22

      Bonjour,

      Je ne trouve pas d'erreur non plus. Le problème vient peut-être du site de simulation (ici tinkercad).

      Si tu as le matériel essaie de réaliser une maquette et tu verras bien.

      Bien cordialement

      • Partager sur Facebook
      • Partager sur Twitter
        Staff 8 mai 2020 à 14:23:52

        Tout le monde n'a pas de compte tinkercad.

        Tu devrais poster ton code ici pour que tous ceux qui n'ont pas de compte puisse y jeter un coup d'oeil et t'aider ;)

        • Partager sur Facebook
        • Partager sur Twitter
          8 mai 2020 à 18:50:59

          Mer

          lorrio a écrit:

          Tout le monde n'a pas de compte tinkercad.

          Tu devrais poster ton code ici pour que tous ceux qui n'ont pas de compte puisse y jeter un coup d'oeil et t'aider ;)

          Pas de problème, merci de ta réponse, le voici : 

          int avancer = 2;   // je nomme mes variables afin de les assigner à une pin

          int reculer = 4;

          int vitesse = 6;

          int v = 0;

          const byte TRIGGER_PIN = 9; // Broche TRIGGER

          const byte ECHO_PIN = 8;    // Broche ECHO

          /* Constantes pour le timeout */

          const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

          /* Vitesse du son dans l'air en mm/us */

          const float SOUND_SPEED = 340.0 / 1000;

          void setup(){

             /* Initialise le port série */

            Serial.begin(115200);

            /* Initialise les broches */

            pinMode(TRIGGER_PIN, OUTPUT);

            digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos

            pinMode(ECHO_PIN, INPUT);

            pinMode(avancer, OUTPUT);    // je definie mes varialbes comme sorties

            pinMode(reculer, OUTPUT);

            pinMode(vitesse, OUTPUT);

          }

          int arret (){

            digitalWrite(avancer,LOW); // je fais un sous programme pour le freinage electromagnétique du robot

            digitalWrite(reculer,LOW);

            analogWrite(vitesse,0);

          }

          int avant(int v){

            digitalWrite(avancer,HIGH); // je fais un sous programme pour faire tourner le moteur (sens horraire)

            digitalWrite(reculer,LOW);

            analogWrite(vitesse,v);

          }

          int arriere(int v){

            digitalWrite(avancer,LOW); // je fais un sous programme pour faire tourner le moteur (sens trigo)

            digitalWrite(reculer,HIGH);

            analogWrite(vitesse,v);

          }

          void loop(){

            /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */

            digitalWrite(TRIGGER_PIN, HIGH);

            delayMicroseconds(10);

            digitalWrite(TRIGGER_PIN, LOW);

            /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */

            long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);

            /* 3. Calcul la distance à partir du temps mesuré */

            float distance_mm = measure / 2.0 * SOUND_SPEED;

            /* Affiche les résultats en mm, cm et m */

            Serial.print(F("Distance: "));

            Serial.print(distance_mm);

            Serial.print(F("mm ("));

            Serial.print(distance_mm / 10.0, 2);

            Serial.print(F("cm, "));

            Serial.print(distance_mm / 1000.0, 2);

            Serial.println(F("m)"));

            /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */

            delay(500);

            if (distance_mm<2000){

              avant(200);

              delayMicroseconds(10000);

              arret ();

              delayMicroseconds(10000);

              arriere(230);

              delayMicroseconds(10000);

              arret ();

            }  

          }

          • Partager sur Facebook
          • Partager sur Twitter
            Staff 8 mai 2020 à 20:13:18

            Avec les balises codes, ce serait beaucoup mieux (cf plus bas sur mon message).

            Il y a un truc qui me parait très étrange dans ton code, c'est cette partie :

            if (distance_mm < 2000) {
                avant(200);
                delayMicroseconds(10000);
                arret();
                delayMicroseconds(10000);
                arriere(230);
                delayMicroseconds(10000);
                arret();
            }

            Si un objet est détecté à moins de 2000mm (soit moins de 2m), alors tu commandes le moteur en avant pendant 10000us, puis arrêt pendant 10000us et retour arrière pendant 10000us, cela me parait extrêmement court !

            Pour rappel, 10000us = 10ms = 0.01 secondes !!!

            Je doute que tu puisses voir quoi que ce soit bouger dans un laps de temps si court.

            D'ailleurs, ton moteur n'aura très clairement même pas le temps de démarrer.

            Je penses que tu t'es trompé d'un facteur 1000 en inversant delayMicroseconds et delay ;)

            **********

            int avancer = 2; // je nomme mes variables afin de les assigner à une pin
            
            int reculer = 4;
            
            int vitesse = 6;
            
            int v = 0;
            
            const byte TRIGGER_PIN = 9; // Broche TRIGGER
            
            const byte ECHO_PIN = 8; // Broche ECHO
            
            /* Constantes pour le timeout */
            
            const unsigned long MEASURE_TIMEOUT = 25000 UL; // 25ms = ~8m à 340m/s
            
            /* Vitesse du son dans l'air en mm/us */
            
            const float SOUND_SPEED = 340.0 / 1000;
            
            void setup() {
                /* Initialise le port série */
                Serial.begin(115200);
                /* Initialise les broches */
                pinMode(TRIGGER_PIN, OUTPUT);
                digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
                pinMode(ECHO_PIN, INPUT);
                pinMode(avancer, OUTPUT); // je definie mes varialbes comme sorties
                pinMode(reculer, OUTPUT);
                pinMode(vitesse, OUTPUT);
            
            }
            
            int arret() {
                digitalWrite(avancer, LOW); // je fais un sous programme pour le freinage electromagnétique du robot
                digitalWrite(reculer, LOW);
                analogWrite(vitesse, 0);
            
            }
            
            int avant(int v) {
                digitalWrite(avancer, HIGH); // je fais un sous programme pour faire tourner le moteur (sens horraire)
                digitalWrite(reculer, LOW);
                analogWrite(vitesse, v);
            
            }
            
            int arriere(int v) {
                digitalWrite(avancer, LOW); // je fais un sous programme pour faire tourner le moteur (sens trigo)
                digitalWrite(reculer, HIGH);
                analogWrite(vitesse, v);
            
            }
            
            void loop() {
                /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
                digitalWrite(TRIGGER_PIN, HIGH);
                delayMicroseconds(10);
                digitalWrite(TRIGGER_PIN, LOW);
                /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
                long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
                /* 3. Calcul la distance à partir du temps mesuré */
                float distance_mm = measure / 2.0 * SOUND_SPEED;
                /* Affiche les résultats en mm, cm et m */
                Serial.print(F("Distance: "));
                Serial.print(distance_mm);
                Serial.print(F("mm ("));
                Serial.print(distance_mm / 10.0, 2);
                Serial.print(F("cm, "));
                Serial.print(distance_mm / 1000.0, 2);
                Serial.println(F("m)"));
                /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
                delay(500);
                if (distance_mm < 2000) {
                    avant(200);
                    delayMicroseconds(10000);
                    arret();
                    delayMicroseconds(10000);
                    arriere(230);
                    delayMicroseconds(10000);
                    arret();
                }
            
            }



            -
            Edité par lorrio 8 mai 2020 à 20:16:11

            • Partager sur Facebook
            • Partager sur Twitter
              8 mai 2020 à 21:35:03

              lorrio a écrit:

              Avec les balises codes, ce serait beaucoup mieux (cf plus bas sur mon message).

              Il y a un truc qui me parait très étrange dans ton code, c'est cette partie :

              if (distance_mm < 2000) {
                  avant(200);
                  delayMicroseconds(10000);
                  arret();
                  delayMicroseconds(10000);
                  arriere(230);
                  delayMicroseconds(10000);
                  arret();
              }

              Si un objet est détecté à moins de 2000mm (soit moins de 2m), alors tu commandes le moteur en avant pendant 10000us, puis arrêt pendant 10000us et retour arrière pendant 10000us, cela me parait extrêmement court !

              Pour rappel, 10000us = 10ms = 0.01 secondes !!!

              Je doute que tu puisses voir quoi que ce soit bouger dans un laps de temps si court.

              D'ailleurs, ton moteur n'aura très clairement même pas le temps de démarrer.

              Je penses que tu t'es trompé d'un facteur 1000 en inversant delayMicroseconds et delay ;)

              ********

              Bonsoir, 

              Tout d'abord merci pour le temps que tu as passé sur mon programme. En effet j'avais une erreur au niveau des delais, mais une fois modifié la simulation ne fonctionne toujours pas :euh:. Aurais-tu une idée ?

              - je te remet le programme ci-dessous : 

              int avancer = 2;   // je nomme mes variables afin de les assigner à une pin
              int reculer = 4;
              int vitesse = 6;
              int v = 0;
              const byte TRIGGER_PIN = 9; // Broche TRIGGER
              const byte ECHO_PIN = 8;    // Broche ECHO
              /* Constantes pour le timeout */
              const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s
              
              /* Vitesse du son dans l'air en mm/us */
              const float SOUND_SPEED = 340.0 / 1000;
              
              void setup(){
                 /* Initialise le port série */
                Serial.begin(115200);
                 
                /* Initialise les broches */
                pinMode(TRIGGER_PIN, OUTPUT);
                digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
                pinMode(ECHO_PIN, INPUT);
                pinMode(avancer, OUTPUT);    // je definie mes varialbes comme sorties
                pinMode(reculer, OUTPUT);
                pinMode(vitesse, OUTPUT);
              }
                
              int arret (){
                digitalWrite(avancer,LOW); // je fais un sous programme pour le freinage electromagnétique du robot
                digitalWrite(reculer,LOW);
                analogWrite(vitesse,0);
              }
              int avant(int v){
                digitalWrite(avancer,HIGH); // je fais un sous programme pour faire tourner le moteur 1 (sens horraire)
                digitalWrite(reculer,LOW);
                analogWrite(vitesse,v);
              }
              int arriere(int v){
                digitalWrite(avancer,LOW); // je fais un sous programme pour faire tourner le moteur 1 (sens trigo)
                digitalWrite(reculer,HIGH);
                analogWrite(vitesse,v);
              }
              
              
              void loop(){
                /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
                digitalWrite(TRIGGER_PIN, HIGH);
                delayMicroseconds(10);
                digitalWrite(TRIGGER_PIN, LOW);
                
                /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
                long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
                 
                /* 3. Calcul la distance à partir du temps mesuré */
                float distance_mm = measure / 2.0 * SOUND_SPEED;
                 
                /* Affiche les résultats en mm, cm et m */
                Serial.print(F("Distance: "));
                Serial.print(distance_mm);
                Serial.print(F("mm ("));
                Serial.print(distance_mm / 10.0, 2);
                Serial.print(F("cm, "));
                Serial.print(distance_mm / 1000.0, 2);
                Serial.println(F("m)"));
                 
                /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
                delay(500);
                
                if (distance_mm<2000){
                  avant(200);
                  delay(1000);
                  arret ();
                  delay(1000);
                  arriere(230);
                  delay(1000);
                  arret ();
                }  
              }






              • Partager sur Facebook
              • Partager sur Twitter
                9 mai 2020 à 22:56:21

                Bonsoir,

                Tout d'abord merci beaucoup pour le temps que tu as passé à lire mon programme. En effet je n'avais pas pris en compte que ce délais était trop court. Mais le problème c'est qu'une fois modifié le programme ne marche toujours pas :euh:. Aurais-tu une idée de ce qui pourrait tout fausser ? 

                Voici le programme que j'ai à présent : (avec les balises code cette fois, désolé je suis nouveau sur la plateforme:))

                Merci d'avance, Bonne soirée.

                int avancer = 2;   // je nomme mes variables afin de les assigner à une pin
                int reculer = 4;
                int vitesse = 6;
                int v = 0;
                const byte TRIGGER_PIN = 9; // Broche TRIGGER
                const byte ECHO_PIN = 8;    // Broche ECHO
                /* Constantes pour le timeout */
                const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s
                
                /* Vitesse du son dans l'air en mm/us */
                const float SOUND_SPEED = 340.0 / 1000;
                
                void setup(){
                   /* Initialise le port série */
                  Serial.begin(115200);
                   
                  /* Initialise les broches */
                  pinMode(TRIGGER_PIN, OUTPUT);
                  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
                  pinMode(ECHO_PIN, INPUT);
                  pinMode(avancer, OUTPUT);    // je definie mes varialbes comme sorties
                  pinMode(reculer, OUTPUT);
                  pinMode(vitesse, OUTPUT);
                }
                  
                int arret (){
                  digitalWrite(avancer,LOW); // je fais un sous programme pour le freinage electromagnétique du robot
                  digitalWrite(reculer,LOW);
                  analogWrite(vitesse,0);
                }
                int avant(int v){
                  digitalWrite(avancer,HIGH); // je fais un sous programme pour faire tourner le moteur 1 (sens horraire)
                  digitalWrite(reculer,LOW);
                  analogWrite(vitesse,v);
                }
                int arriere(int v){
                  digitalWrite(avancer,LOW); // je fais un sous programme pour faire tourner le moteur 1 (sens trigo)
                  digitalWrite(reculer,HIGH);
                  analogWrite(vitesse,v);
                }
                
                
                void loop(){
                  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
                  digitalWrite(TRIGGER_PIN, HIGH);
                  delayMicroseconds(10);
                  digitalWrite(TRIGGER_PIN, LOW);
                  
                  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
                  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
                   
                  /* 3. Calcul la distance à partir du temps mesuré */
                  float distance_mm = measure / 2.0 * SOUND_SPEED;
                   
                  /* Affiche les résultats en mm, cm et m */
                  Serial.print(F("Distance: "));
                  Serial.print(distance_mm);
                  Serial.print(F("mm ("));
                  Serial.print(distance_mm / 10.0, 2);
                  Serial.print(F("cm, "));
                  Serial.print(distance_mm / 1000.0, 2);
                  Serial.println(F("m)"));
                   
                  /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
                  delay(500);
                  
                  if (distance_mm<2000){
                    avant(200);
                    delay(1000);
                    arret ();
                    delay(1000);
                    arriere(230);
                    delay(1000);
                    arret ();
                  }  
                }



                lorrio a écrit:

                Avec les balises codes, ce serait beaucoup mieux (cf plus bas sur mon message).

                Il y a un truc qui me parait très étrange dans ton code, c'est cette partie :

                if (distance_mm < 2000) {
                    avant(200);
                    delayMicroseconds(10000);
                    arret();
                    delayMicroseconds(10000);
                    arriere(230);
                    delayMicroseconds(10000);
                    arret();
                }

                Si un objet est détecté à moins de 2000mm (soit moins de 2m), alors tu commandes le moteur en avant pendant 10000us, puis arrêt pendant 10000us et retour arrière pendant 10000us, cela me parait extrêmement court !

                Pour rappel, 10000us = 10ms = 0.01 secondes !!!

                Je doute que tu puisses voir quoi que ce soit bouger dans un laps de temps si court.

                D'ailleurs, ton moteur n'aura très clairement même pas le temps de démarrer.

                Je penses que tu t'es trompé d'un facteur 1000 en inversant delayMicroseconds et delay ;)

                **********

                • Partager sur Facebook
                • Partager sur Twitter
                  Staff 10 mai 2020 à 10:50:20

                  Avec ces corrections, je ne vois pas ce qu'il pourrait y avoir comme problème.

                  Que vous tu s'afficher comme distance dans la console Arduino ?

                  • Partager sur Facebook
                  • Partager sur Twitter
                    10 mai 2020 à 12:20:22

                    Voici une photo de mon câblage et de l'affichage des distances. L'erreur est peut-être ici ?

                    Merci d'avance, Bonne journée à vous :

                    • Partager sur Facebook
                    • Partager sur Twitter
                      11 mai 2020 à 15:56:27

                      Je ne comprend pas ce que tu veux dire pas là, mes pôles négatifs sont bien reliés sur la bande négative de ma breadboard qui elle est réliée au GND ?
                      • Partager sur Facebook
                      • Partager sur Twitter
                        Staff 11 mai 2020 à 17:06:32

                        Le L293D dispose de 4 pins GND.

                        Tu as bien relié les pins 12 et 13 mais pas les pins 4 et 5.

                        • Partager sur Facebook
                        • Partager sur Twitter
                          11 mai 2020 à 19:26:04

                          Dacc je crois avoir comprend comme ca ce serait mieux ? (même en les raccordant la simulations ne fonctionne pas)

                          encore merci pour le temps que tu passes pour moi, Bonne soirée.

                          lorrio a écrit:

                          Le L293D dispose de 4 pins GND.

                          Tu as bien relié les pins 12 et 13 mais pas les pins 4 et 5.



                          • Partager sur Facebook
                          • Partager sur Twitter
                            Staff 12 mai 2020 à 8:10:36

                            Oui, là, c'est beaucoup mieux.

                            Le code me semble correct, le schéma aussi.

                            Peut-être que le problème vient du simulateur.

                            • Partager sur Facebook
                            • Partager sur Twitter
                              12 mai 2020 à 9:45:51

                              Dacc merci, je n'ai pas le matériel pour le moment donc je ne peux pas tester :euh:
                              • Partager sur Facebook
                              • Partager sur Twitter

                              commande moteur par ultrason Arduino

                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                              • Editeur
                              • Markdown